O Guia Completo do C# 14: Novidades do .NET 10

1. Simplifique Propriedades com a Palavra-Chave field

O C# 14 introduz a palavra-chave contextual field, que permite acessar o backing field oculto de uma propriedade autoimplementada diretamente em seus métodos get e set. Esse novo recurso elimina a necessidade de declarar manualmente campos privados apenas para adicionar validações simples.

Antes do C# 14

As propriedades autoimplementadas sempre foram ótimas pela sua sintaxe concisa. No entanto, essa simplicidade sumia assim que você precisava de uma lógica extra no getter ou setter. Você era obrigado a abandonar a propriedade autoimplementada e definir um campo privado manualmente:

C#

private string _name;
public string Name
{
    get => _name;
    set => _name = value ?? throw new ArgumentNullException(nameof(value));
}

A Solução no C# 14

Com a nova palavra-chave field, você injeta lógica diretamente nos assessores sem precisar criar seu próprio campo privado. Você mantém a elegância das propriedades autoimplementadas enquanto personaliza o comportamento:

C#

public string Name
{
    get => field;
    set => field = value ?? throw new ArgumentNullException(nameof(value));
}

⚠️ Atenção: A palavra-chave field é contextual, ou seja, ela só existe dentro do get e set da propriedade. Você não pode acessá-la de outros métodos ou construtores. Além disso, se sua classe já tiver um membro chamado field, ele será ocultado (shadowed) pelo novo recurso, gerando avisos do compilador. É altamente recomendável evitar esse nome a partir de agora.

Por que usar?

• Código limpo: Evita a poluição de campos privados (_nome, _idade) no escopo global da classe.
• Propriedades autocontidas: Toda a lógica de validação fica encapsulada no bloco da própria propriedade.

2. Organize Extensões de Tipo com Blocos de Extensão (Extension Blocks)

Os blocos de extensão são uma das maiores mudanças de sintaxe do C# 14. Eles agrupam todos os membros de extensão de um tipo dentro de um único bloco limpo. Além da organização, os blocos de extensão permitem definir muito mais do que apenas métodos: agora você pode criar propriedades de extensão, métodos estáticos e sobrecarga de operadores para tipos de terceiros.

Antes do C# 14

Desde o C# 3.0, os métodos de extensão exigiam uma classe estática e a repetição do modificador this em cada assinatura de método:

C#

public static class EnumerableExtensions
{
    public static T FirstOrFallback<T>(this IEnumerable<T> enumerable, T fallback)
        => enumerable.FirstOrDefault() ?? fallback;
}

A Solução no C# 14

Agora, a sintaxe extension define o tipo alvo uma única vez no topo do bloco. Veja como estendemos o tipo IEnumerable<T> com propriedade, método comum, método estático e até um operador de soma (+):

C#

public static class EnumerableExtensions
{
    extension<T>(IEnumerable<T> enumerable)
    {
        // Propriedade de Extensão (Extension Property)
        public bool IsEmpty => !enumerable.Any();

        // Método de Extensão com sintaxe limpa (sem 'this')
        public T FirstOrFallback(T fallback)
            => enumerable.FirstOrDefault() ?? fallback;
        
        // Método Estático de Extensão (Static Extension)
        public static IEnumerable<T> Range(int start, int count, Func<int, T> generator)
            => Enumerable.Range(start, count).Select((_, i) => generator(i));
        
        // Operador de Extensão (Extension Operator)
        public static IEnumerable<T> operator +(IEnumerable<T> first, IEnumerable<T> second)
        {
            foreach (var item in first) yield return item;
            foreach (var item in second) yield return item;
        }
    }
}

Todos esses membros podem ser consumidos naturalmente, como se fizessem parte do tipo original:

C#

var emptyList = new List<string>();
if (emptyList.IsEmpty) { /* ... */ }

var listA = new[] { 1, 2 };
var listB = new[] { 3, 4 };
var combinedList = listA + listB; // Uso do operador estendido!

// Chamada de método estático diretamente na interface
var generatedIds = IEnumerable<string>.Range(10, 5, i => $"ID-{i}");

Por que usar?

• Fim da repetição: Não é preciso repetir this SeuTipo nome em dezenas de métodos.
• Novos superpoderes: Abre as portas para propriedades e operadores customizados em tipos que você não controla (como classes do próprio .NET ou pacotes NuGet).

3. Reduza Boilerplate com Construtores e Eventos Parciais (Partial)

Membros parciais permitem dividir a definição e a implementação de um membro da classe. Isso é amplamente utilizado por Source Generators (geradores de código automáticos). O C# 14 expande esse suporte para construtores e eventos.

Antes do C# 14

Como os construtores não podiam ser parciais, o gerador de código precisava criar um método parcial (ex: Initialize()) e o desenvolvedor era obrigado a lembrar de chamar esse método dentro do construtor manual.

A Solução no C# 14

Agora, tanto a assinatura do construtor quanto a do evento podem ser marcadas diretamente como partial:

C#

// Arquivo do desenvolvedor: Config.cs
public partial class Config
{
    public partial event EventHandler ConfigReloaded;
    public partial Config(string configPath);
}

// Arquivo gerado automaticamente: Config.g.cs
public partial class Config
{
    private EventHandler? _configReloaded;
    
    public partial event EventHandler ConfigReloaded
    {
        add => _configReloaded += value;
        remove => _configReloaded -= value;
    }
    
    public partial Config(string configPath)
    {
        // Implementação gerada pelo Source Generator
    }
}

Por que usar?

• Integração perfeita com tooling: Se você desenvolve ou consome ferramentas que geram código em tempo de compilação, o design das suas classes fica muito mais limpo, sem necessidade de métodos de gancho (hooks) artificiais.

4. Atribuição Condicional a Nulo (Null-Conditional Assignment)

O operador condicional de nulo (?.) agora foi habilitado para funcionar do lado esquerdo de uma expressão de atribuição.

Antes do C# 14

Para evitar uma NullReferenceException, você precisava criar uma estrutura de decisão if explícita antes de alterar a propriedade de um objeto que pudesse ser nulo:

C#

if (policy is not null)
{
    policy.CustomerId = customerId;
}

A Solução no C# 14

Agora você pode condensar essa validação e a atribuição diretamente em uma única linha de código:

C#

policy?.CustomerId = customerId;

Se policy for nulo, a atribuição é ignorada com total segurança, e a expressão do lado direito (customerId) sequer é avaliada, poupando processamento e evitando efeitos colaterais.

Por que usar?

• Fluidez visual: Torna o código linear, eliminando blocos if aninhados que servem apenas para checagens defensivas de nulo.

5. Operadores de Atribuição Composta Definidos pelo Usuário

No C# 14, você pode criar sobrecargas explícitas para operadores compostos como +=, -=, e semelhantes. Isso traz um ganho substancial em cenários de alta performance.

Antes do C# 14

Ao sobrecarregar o operador +, o compilador o utilizava tanto para a + b quanto para a += b. O problema é que a operação comum de soma sempre retorna uma nova instância do objeto, gerando alocações de memória desnecessárias no caso de atribuições compostas.

A Solução no C# 14

Agora você pode criar um método específico para alterar a própria instância atual (this) diretamente, sem gerar novos objetos no heap:

C#

public struct Money(string currency, decimal amount)
{
    public decimal Amount { get; set; } = amount;
    public string Currency { get; set; } = currency;

    // Sobrecarga direta e otimizada para o +=
    public void operator += (Money b)
    {
        if (this.Currency != b.Currency)
            throw new InvalidOperationException("Moedas diferentes.");
        
        this.Amount += b.Amount; // Modifica o próprio estado alocado
    }
}

Por que usar?

• Otimização de memória: Evita cópias de estruturas e alocações temporárias do Garbage Collector em loops intensivos.

6. Modificadores de Parâmetros em Lambdas Sem Tipos Explícitos

As expressões lambda agora aceitam modificadores como ref, in, out, scoped e ref readonly sem exigir que você declare explicitamente o tipo da variável, desde que o compilador consiga deduzi-lo do contexto.

Antes do C# 14

Se você precisasse passar uma variável por referência (ref) dentro de uma lambda, o compilador te obrigava a escrever o tipo completo do parâmetro:

C#

delegate void ApplyDiscount(ref decimal money);
ApplyDiscount apply10Percent = (ref decimal price) => price *= 0.9m;

A Solução no C# 14

Basta omitir o tipo e manter apenas o modificador:

C#

ApplyDiscount apply20Percent = (ref price) => price *= 0.8m;

7. Melhoria no nameof para Genéricos Não Limitados (Unbounded Generics)

O operador nameof serve para obter a representação em string do nome de um símbolo, variável ou tipo. O C# 14 corrige uma limitação histórica ao lidar com tipos genéricos puros.

Antes do C# 14

Para capturar o nome de uma classe genérica como List<T>, você era forçado a passar um tipo arbitrário qualquer (como string ou int) apenas para fazer o código compilar:

C#

Console.WriteLine(nameof(List<string>)); // Saída: "List"

A Solução no C# 14

Agora você pode usar a sintaxe nativa de tipos genéricos abertos (com a vírgula ou omitindo o tipo nas chaves):

C#

Console.WriteLine(nameof(List<>)); // Saída: "List"

8. Conversões Implícitas para Span<T> e ReadOnlySpan<T>

Tipos baseados em memória eficiente, como Span<T> e ReadOnlySpan<T>, ganharam suporte de primeira classe no compilador com novos operadores de conversão implícita.

Antes do C# 14

Ao passar arrays diretamente para assinaturas de métodos que aceitavam spans genéricos, o compilador frequentemente falhava em inferir o tipo e exigia conversões explícitas ou argumentos extras de tipagem:

C#

// Exigia a tipagem explícita no método <int> para converter o array
var sd = CalculateStandardDeviation<int>(new[] { 3, 5, 3 });

A Solução no C# 14

A resolução de tipos agora funciona de forma transparente. O array é convertido implicitamente para o span correspondente sem código adicional:

C#

var sd = CalculateStandardDeviation(new[] { 3, 5, 3 });

Conclusão

O C# 14 foca massivamente em eliminar fricção sintática. Recursos como a palavra-chave field e os blocos de extension mudam a forma como estruturamos códigos cotidianos, enquanto as melhorias de operadores compostos e conversões de Span garantem que o ecossistema continue sendo uma das opções mais rápidas para o desenvolvimento moderno.

Para começar a usar esses recursos hoje mesmo, certifique-se de atualizar o SDK do seu ambiente para o .NET 10 e configurar a tag do compilador no seu arquivo .csproj se estiver testando versões prévias: