.NET 10 e C# 14: Mudanças no Null

O que são nulos no C#

Em C#, null representa a ausência de valor em tipos por referência, como classes, interfaces, arrays e delegates. Ou seja, a variável existe, mas não aponta para nenhuma instância válida.

string? name = null;

Nulls existem como uma forma de representar a ausência de um valor ou de um objeto. Por exemplo, eles indicam que uma informação ainda não foi fornecida ou que um recurso está indisponível.

Também servem para sinalizar que não há um valor aplicável em determinado contexto. No entanto, essa utilidade tem um preço: acessar membros de uma referência nula gera exceções em tempo de execução.

NullReferenceException: o erro mais comum

A famosa NullReferenceException ocorre quando tentamos acessar um membro (propriedade, método, indexador) de uma referência nula. Veja um exemplo simples:

Person person = null;
Console.WriteLine(person.Name);
// lança NullReferenceException

Esse tipo de erro é comum em aplicações que não validam a existência de um objeto antes de acessá-lo, e continua possível com o null no C# 14. Além disso, ele costuma aparecer longe da origem do problema, o que dificulta o diagnóstico.

Para evitar a exceção, o caminho clássico é verificar explicitamente se a referência é nula antes de usá-la:

if (person is not null)
{
    Console.WriteLine(person.Name);
}

Embora funcione, essa abordagem se torna repetitiva em sistemas grandes. Afinal, muitos objetos circulam por diferentes camadas da aplicação.

O excesso de verificações polui o código e dificulta a leitura. Por outro lado, basta esquecer uma única checagem para que a exceção apareça em produção.

Foi esse desafio que levou à criação dos operadores ?., ?? e, mais recentemente, da atribuição condicional que define o tratamento de null no C# 14.

Nullable reference types e os warnings de compilação

A partir do C# 8, o compilador passou a oferecer os nullable reference types. Com eles, você indica explicitamente quando um tipo por referência pode ou não ser nulo.

No contexto de null no C# 14, essa base continua a mesma.

Na prática, string passa a significar "nunca nulo" e string? passa a significar "talvez nulo". Contudo, a anotação não muda o tipo em tempo de execução, porque as duas formas continuam sendo System.String.

A diferença está na análise estática. O compilador acompanha o estado de cada variável (not-null ou maybe-null) e emite warnings quando o código pode desreferenciar um valor nulo.

<PropertyGroup>
  <Nullable>enable</Nullable>
</PropertyGroup>

public class Customer
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

Operadores de coalescência nula: ?? e ??=

A coalescência nula é um recurso importante para fornecer valores padrão quando algo vale null. O operador ?? devolve o operando da esquerda quando ele não é nulo e, caso contrário, devolve o da direita.

string? name = null;
string finalName = name ?? "Unknown";

Já o operador ??= faz a atribuição direta, mas somente quando a variável ainda está nula:

name ??= "Guest";

Um detalhe importante é que o lado direito do ??= só roda quando a variável vale null. Por isso, ele funciona muito bem para inicialização preguiçosa, como em um cache carregado sob demanda.

List<string>? cache = null;

// LoadData só é chamado na primeira vez
cache ??= LoadData();
cache ??= LoadData();

static List<string> LoadData() => ["alpha", "beta", "gamma"];

Esses operadores reduzem a necessidade de verificações explícitas e seguem válidos com o null no C# 14. Assim, o código fica mais enxuto e mais expressivo.

Operador condicional nulo: ?. e ?[]

Antes de falar da novidade, vale revisar o operador condicional nulo, disponível desde o C# 6. Ele permite acessar um membro somente quando o objeto não é nulo.

int? length = customer?.Name?.Length;
string? firstTag = tags?[0];

Se customer ou Name forem nulos, a expressão inteira resulta em null, sem exceção. Além disso, o operador avalia o operando da esquerda uma única vez.

É comum combinar ?. com ?? para obter um valor final não nulo:

int length = customer?.Name?.Length ?? 0;

Até o C# 13, porém, esse operador só funcionava para leitura. Ou seja, você não podia usá-lo do lado esquerdo de uma atribuição, e é justamente isso que muda com o null no C# 14.

Atribuição condicional nula: a novidade de null no C# 14

A principal novidade de null no C# 14 é o suporte aos operadores ?. e ?[] no lado esquerdo de uma atribuição. O recurso se chama null-conditional assignment e faz parte da lista oficial de novidades do C# 14.

O C# 14 roda no .NET 10, lançado em novembro de 2025. Portanto, basta usar o SDK do .NET 10 para ter acesso à nova sintaxe.

if (customer is not null)
{
    customer.Order = GetCurrentOrder();
}

customer?.Order = GetCurrentOrder();

messages?[5] = "five";
values?[2] = GenerateNextIndex();

customer?.Total += 100;
customer?.Total -= discount;

button?.Clicked += OnButtonClicked;

customer?.Visits++; // erro
--customer?.Visits; // erro

Como o null no C# 14 é avaliado

Entender a semântica evita surpresas. Segundo a especificação da atribuição condicional nula, P?.A = B equivale a if (P is not null) P.A = B;.

A diferença é que P é avaliado uma única vez. Isso importa quando P é uma chamada de método ou uma expressão com efeitos colaterais.

Quando você usa o resultado da expressão, o comportamento muda um pouco. Nesse caso, P?.A = B equivale a (P is null) ? (T?)null : (P.A = B).

Em outras palavras, a expressão devolve null se o receptor for nulo e devolve o valor atribuído caso contrário. Veja um exemplo com encadeamento:

// CalculateDiscount só executa se order e order.Customer não forem nulos
order?.Customer?.Discount = CalculateDiscount();

Aqui, o compilador verifica order e, em seguida, order.Customer. Assim, CalculateDiscount() só roda quando os dois existem.

Outro ponto curioso é a combinação com ??=. A linha a?.b ??= c; atribui c somente se a existir e se a.b ainda estiver nulo.

// Cria o endereço só quando o cliente existe e ainda não tem endereço
customer?.Address ??= new Address();

Esse padrão é útil para inicializar propriedades opcionais sem escrever dois if aninhados. Portanto, ele resume bem a proposta do null no C# 14: menos cerimônia com o mesmo nível de segurança.

O que muda no .NET 10 para o tratamento de null no C# 14

O C# 14 é a versão da linguagem suportada oficialmente pelo .NET 10. Por isso, ao criar um projeto com o SDK do .NET 10, a atribuição condicional nula já está disponível sem configuração extra.

Os nullable reference types continuam funcionando da mesma forma que nas versões anteriores. Na prática, o que o .NET 10 traz para o tema é a nova sintaxe de atribuição, somada a toda a base que já existia.

Vale notar que o C# 14 trouxe outras novidades no mesmo pacote, como a palavra-chave field e os extension members. Se esse último tema interessa, o artigo sobre o novo modelo de extension members no C# 14 aprofunda o assunto.

Já a atribuição condicional tem um texto dedicado aqui no blog. O artigo atribuição condicional nula no C# 14 traz mais exemplos focados só nesse operador.

Para quem está migrando de versões antigas, a recomendação é simples. Primeiro, habilite o contexto nullable; em seguida, resolva os warnings; por fim, use a nova sintaxe para simplificar as verificações que sobraram.

Boas práticas com null no C# 14

A nova sintaxe é poderosa, mas não substitui um bom desenho de tipos. Dessa forma, algumas práticas continuam valendo mesmo com o null no C# 14.

• Deixe o contexto nullable ligado: os warnings apontam problemas antes de eles chegarem à produção.
• Prefira tipos não anuláveis: use ? apenas quando a ausência de valor fizer sentido para o domínio.
• Evite o operador ! como atalho: ele apenas silencia o warning, enquanto o risco continua no código.
• Use ?.= para efeitos opcionais: ele funciona bem quando ignorar o objeto nulo é o comportamento correto.
• Valide entradas nas bordas: em métodos públicos, ArgumentNullException.ThrowIfNull deixa a intenção clara.

Um cuidado importante é não esconder erros com a nova sintaxe. Se um objeto nunca deveria ser nulo, a atribuição condicional vai simplesmente ignorar a linha, e o bug passa despercebido.

Nesse caso, é melhor deixar a exceção acontecer ou validar a entrada logo no início do método. Afinal, falhar cedo costuma ser mais barato do que falhar em silêncio.

public void UpdateOrder(Customer customer, Order order)
{
    // Falha cedo quando o contrato do método não é respeitado
    ArgumentNullException.ThrowIfNull(customer);

    customer.Order = order;
}

Por outro lado, quando o objeto é opcional por natureza, o ?.= deixa o código mais limpo. Um exemplo clássico é atualizar um componente de interface que pode ainda não ter sido criado.

Conclusão

Nulls continuarão existindo, mas agora temos mais controle, segurança e produtividade ao lidar com eles. Os nullable reference types avisam sobre riscos, os operadores ?? e ??= fornecem valores padrão e o ?. lê dados com segurança.

Com o null no C# 14, o ciclo se completa com a atribuição condicional. Assim, o if defensivo de três linhas vira uma única instrução, sem perder a garantia de que nada roda sobre um objeto nulo.

A evolução constante da linguagem mostra um forte compromisso com código mais robusto e expressivo. Por isso, se você ainda não usa o contexto nullable e os operadores de coalescência, talvez seja a hora de reconsiderar.

O próximo passo é abrir um projeto no .NET 10, ligar o contexto nullable e experimentar a nova sintaxe. Com isso, você coloca o tratamento de null no C# 14 literalmente na palma das suas ?. mãos.

FAQ

O que é a atribuição condicional nula no C# 14?

É a possibilidade de usar ?. e ?[] do lado esquerdo de uma atribuição. A atribuição só acontece se o objeto não for nulo.

Preciso do .NET 10 para usar a atribuição condicional nula?

Sim, o recurso faz parte do C# 14, que é a versão da linguagem suportada pelo .NET 10. Basta usar o SDK do .NET 10.

O lado direito da atribuição é executado quando o objeto é nulo?

Não. O lado direito só é avaliado quando o receptor da expressão condicional não é nulo.

Posso usar ++ e -- com a nova sintaxe?

Não, incremento e decremento não são permitidos. Atribuições compostas como += e -= funcionam normalmente.

Os nullable reference types mudaram no C# 14?

Não. Eles seguem o mesmo modelo introduzido no C# 8 e ativado por padrão nos templates desde o .NET 6.

Quando não devo usar ?.=?

Evite quando o objeto nunca deveria ser nulo. Nesse caso, a sintaxe esconderia um bug que deveria gerar erro.