██FR█████ █INTELL███████████

De C# 7.2 para C# 7.3 – Otimizações por referência, generics mais fortes e código mais seguro


This content originally appeared on DEV Community and was authored by Danilo O. Pinheiro, dopme.io

As versões 7.2 e 7.3 do C# representam uma fase em que a Microsoft refinou recursos introduzidos no C# 7.0 e 7.1, especialmente relacionados a performance com structs, acesso seguro à memória e melhorias em generics.

Se você trabalha com .NET Core, microsserviços, bibliotecas otimizadas ou sistemas que exigem alta performance, essas versões trazem recursos valiosos.

📦 O que o C# 7.2 trouxe? (2017)

O foco foi passagem por referência otimizada e controle de visibilidade. Ideal para cenários onde cada byte ou CPU conta.

✅ Principais recursos do C# 7.2

Recurso Descrição
in parameters Passagem de parâmetros por referência imutável
ref readonly Retorno por referência com somente leitura
readonly struct Structs imutáveis por contrato
private protected Modificador que combina protected + internal restrito
Suporte aprimorado a Span<T> Base para manipulação eficiente de buffers e strings

🔧 Exemplo – in parameters 

public void Calcular(in Vector3 vetor)
{
    // vetor é passado por referência, mas não pode ser alterado
}

🧠 Ideal para performance em structs grandes, sem cópia de valor.

🔧 Exemplo – readonly struct 

public readonly struct Moeda
{
    public decimal Valor { get; }
    public string Sigla { get; }

    public Moeda(decimal valor, string sigla)
    {
        Valor = valor;
        Sigla = sigla;
    }
}

📦 Excelente para Value Objects em DDD.

🔐 Exemplo – private protected 

private protected void Validar()
{
    // visível apenas em classes derivadas dentro do mesmo assembly
}

🔐 Mais controle de encapsulamento para bibliotecas ou SDKs.

📦 O que mudou no C# 7.3? (2018)

A versão 7.3 aprimorou recursos já existentes com foco em segurança de tipos, performance e expressividade — especialmente em cenários com ref, generics e sobrecarga de métodos.

✅ Principais recursos do C# 7.3

Recurso Descrição
Passagem por ref em mais contextos Suporte a ref, in, out em lambdas, métodos anônimos etc.
Comparações mais seguras com genéricos where T : unmanaged, enum, delegate
Inferência de tipo aprimorada Melhor dedução de tipos em ternários e inferência de retorno
Fixação de arrays em stack (stackalloc) Suporte a inicialização inline
Sobrecarga com params e ref Melhor resolução de métodos com múltiplos parâmetros

🔧 Exemplo – where T : unmanaged 

public unsafe void AlocarMemoria<T>() where T : unmanaged
{
    T* ptr = stackalloc T[10];
}

🔬 Garante que o tipo não possui referências, permitindo uso seguro em código nativo.

🔧 Exemplo – Melhor inferência em ternários 

var idade = true ? 42 : GetIdade();

int GetIdade() => 30;

🧠 O compilador deduz int mesmo com expressões mistas.

🔧 Exemplo – ref em lambdas 

Span<int> numeros = stackalloc int[] { 1, 2, 3 };

ref int GetNumero(int i) => ref numeros[i];

🔄 Permite retorno por referência direto de métodos auxiliares.

⚖ Comparativo resumido – C# 7.2 vs C# 7.3

Funcionalidade C# 7.2 C# 7.3
in, ref readonly, readonly struct ✅ ✅
private protected ✅ ✅
where T : unmanaged / enum ❌ ✅
ref em lambdas e expressões ❌ ✅
stackalloc melhorado ❌ ✅
Inferência de tipo aprimorada ❌ ✅
Sobrecarga com params + ref ❌ ✅

🎓 Quando usar cada versão?

✅ Use C# 7.2 se:

  • Precisa evitar cópias de structs grandes
  • Quer declarar structs como imutáveis
  • Deseja maior controle sobre visibilidade em SDKs ou libs

✅ Use C# 7.3 se:

  • Trabalha com generics e segurança de tipos
  • Precisa de retornos por referência otimizados
  • Está otimizando baixo nível ou código com ponteiros
  • Precisa resolver conflitos de sobrecarga com params/ref

🛠 Como ativar essas versões?

No seu .csproj, defina:

<LangVersion>7.3</LangVersion>

Ou use:

<LangVersion>latest</LangVersion>

📘 Conclusão

As versões 7.2 e 7.3 marcaram uma era de refinamento no C#. A linguagem ganhou controle mais preciso sobre memória e performance, sem perder clareza e segurança de código.

💡 C# 7.2 foca em referência segura e imutabilidade.
💡 C# 7.3 aprofunda esse controle, trazendo mais poder para generics e código de alta performance.

🤝 Conecte-se Comigo

Se você curte otimizar código, explorar novas versões de C# ou aplicar boas práticas em arquitetura .NET, vamos conversar:


This content originally appeared on DEV Community and was authored by Danilo O. Pinheiro, dopme.io