C# distingue tipos que podem ser daqueles que não podem. () permitem que tipos de valor contenham null, (um recurso do compilador) ajudam a detectar bugs de null, e (, , ) tornam o trabalho com valores possivelmente nulos limpo e seguro — abordando o problema onipresente de referência nula.
nullint??.??!int x = 5; // a value type — CANNOT be null
int? y = null; // int? = Nullable<int> — CAN be null
if (y.HasValue) { int val = y.Value; } // check + access
int z = y ?? 0; // default if null
Tipos de valor normalmente não podem ser null, mas int? (Nullable<int>) permite isso — comum para dados opcionais/ausentes (por exemplo, uma coluna de banco de dados anulável).
#nullable enable // (on by default in modern projects)
string name = null; // ⚠️ warning — string is non-nullable by default now
string? maybe = null; // ✅ string? explicitly allows null
void Use(string? s) {
Console.WriteLine(s.Length); // ⚠️ warning — s might be null (must check first)
}
Com tipos de referência anuláveis ativados, o compilador rastreia quais referências podem ser null (string?) versus não (string) e avisa quando você pode desreferenciar null — detectando bugs de NullReferenceException em tempo de compilação. Este é um recurso de segurança C# moderno importante.
// ?. null-conditional — short-circuits to null instead of throwing
int? len = user?.Name?.Length; // null if user or Name is null (no exception)
user?.DoSomething(); // only calls if user isn't null
// ?? null-coalescing — provide a default
string name = input ?? "Anonymous";
name ??= "fallback"; // assign if currently null
// ! null-forgiving — assert non-null (suppress the warning; use carefully)
string definitelyNotNull = maybe!; // "I know it's not null" — no runtime check
O operador condicional de nulo (?.) acessa com segurança membros de valores possivelmente nulos (retornando null em vez de lançar uma exceção), e ?? fornece padrões — juntos tornando o tratamento de null limpo e seguro.
O tratamento de null é um dos aspectos mais importantes da escrita de C# robusto, já que NullReferenceException ("o erro de um bilhão de dólares") é um dos erros de tempo de execução mais comuns — e os tipos anuláveis e operadores de C# tratam disso diretamente, tornando-os conhecimento essencial. Tipos de valor anuláveis (int?) são praticamente necessários para representar dados opcionais/ausentes (campos de banco de dados anuláveis, valores opcionais).
O recurso tipos de referência anuláveis (agora ativado por padrão em projetos modernos do .NET) é uma grande melhoria de segurança: ao fazer o compilador rastrear e avisar sobre possíveis desreferenciações de null, ele detecta toda uma classe de bugs de null em tempo de compilação em vez de como travamentos de tempo de execução — um benefício significativo de confiabilidade que você deve entender e considerar.
Os operadores de tratamento de nulo são ferramentas do dia a dia que tornam o trabalho com valores possivelmente nulos limpo e seguro: o operador condicional de nulo (?.) navega com segurança cadeias possivelmente nulas (retornando null em vez de lançar), ??/??= fornecem padrões de forma concisa, e ! afirma não-nulidade (para ser usado com cuidado).
Compreender tipos de valor anuláveis, o recurso de segurança de tipos de referência anuláveis, e os operadores de tratamento de nulo (?., ??, !) é importante para escrever C# seguro em relação a null e robusto que evita a NullReferenceException onipresente — uma preocupação frequente e praticamente crítica.
Como bugs relacionados a null são tão comuns e C# fornece ferramentas fortes (especialmente verificação de null em tempo de compilação) para evitá-los, dominar tipos anuláveis e operadores de null é conhecimento fundamental e essencial para escrever C# moderno confiável.