1. Introdução
Por que NRT precisa ser ativado manualmente?
Nullable Reference Types (NRT) não é só um açúcar sintático, é um baita ajudante do compilador pra evitar bugs relacionados a null. Mas, por motivos históricos, esse modo não vem ativado por padrão em projetos antigos — pra não quebrar compatibilidade. Se você cria um projeto novo nas últimas versões do .NET (tipo .NET 7, 8 ou 9), provavelmente o NRT já tá ligado. Mas se o projeto é velhinho ou você quer controlar isso na mão, tem que ativar explicitamente.
O que faz o modo Nullable Reference Types?
Quando esse modo tá ativo, o compilador começa a analisar quais variáveis de referência podem ser null e quais não podem. Ele não interfere na execução do programa, mas vai te encher de avisos se enxergar um possível erro. É um jeito massa de escrever código mais confiável, claro e robusto.
Como saber se o NRT tá ativado?
Se seu projeto é novo, tipo .NET 6 ou mais recente, provavelmente o NRT já tá ligado. Mas nunca se sabe. Bora conferir!
- Abre o arquivo do projeto. Normalmente é o arquivo com extensão .csproj.
- Acha ou adiciona a config <Nullable> dentro da primeira tag <PropertyGroup>.
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net9.0</TargetFramework>
<Nullable>enable</Nullable>
</PropertyGroup>
</Project>
Se lá tiver <Nullable>disable</Nullable>, então o controle de NRT tá desligado.
2. Como ativar o modo NRT
Pelo .csproj — pro projeto inteiro
- Abre (ou cria) o arquivo .csproj.
- Dentro do bloco <PropertyGroup> adiciona ou muda a linha:
<Nullable>enable</Nullable>
Agora o compilador vai ficar de olho em todos os arquivos .cs do projeto e reclamar de acessos perigosos a null.
Por que fazer isso?
Porque é uma config global. Daqui pra frente, o projeto inteiro segue as novas regras: null tá sempre sob suspeita, e descuido não passa mais!
Só pra arquivos ou trechos específicos
Se você ainda não tá pronto pra ativar o modo estrito no projeto todo, pode testar em arquivos separados. Pra isso, usa as diretivas do pré-processador:
#nullable enable
string? value = null; // Aqui a análise tá ligada
#nullable disable
string legacyValue = null; // Aqui já não tá mais
#nullable restore
- #nullable enable — ativa a checagem até o fim do arquivo.
- #nullable disable — desativa.
- #nullable restore — volta pras configs do .csproj ou arquivo externo.
Isso é prático: dá pra ativar o controle estrito nos módulos novos sem mexer no código velho e instável.
O que mais dá pra colocar em <Nullable>
| Valor | Comportamento |
|---|---|
|
Ativa tudo: anotações e avisos |
|
Desliga totalmente a análise de null |
|
Só mostra avisos, sem exigir anotações |
|
Precisa de anotações, mas o compilador não reclama |
|
Volta pro comportamento original (tipo da config global) |
Normalmente se usa enable ou disable.
3. Demonstração com exemplo
Antes de ativar o NRT
// Modo antigo, NRT desligado
string s = null; // Ninguém reclama
Console.WriteLine(s.Length); // Perigoso! Pode rolar NullReferenceException
Depois de ativar o NRT
// Modo novo, NRT ligado
string s = null; // Aviso: possível atribuição de null
Console.WriteLine(s.Length); // Aviso: possível acesso a null
Agora a IDE vai sublinhar os problemas e o compilador avisa: Dereference of a possibly null reference. (CS8602)
Como resolver?
string? s = null;
if (s != null)
{
Console.WriteLine(s.Length);
}
Assim você deixa claro: essa variável pode ser null, e o compilador fica feliz.
4. O que fazer se o projeto for "das antigas"?
Muita coisa foi feita numa época em que null tava em toda variável de referência. Ligando o NRT, é como se você contratasse um fiscal chato que vai avisar de cada possível problema.
E se aparecer aviso demais?
Relaxa — isso não são erros, só dicas. O programa ainda compila de boa.
- Pode ativar NRT só nos arquivos novos.
- Vai arrumando o código aos poucos: coloca ?, faz checagem de null, usa ! (falo disso depois).
- Lembra: quanto mais cuidado com null, menos dor de cabeça depois.
Compatibilidade e libs de terceiros
- Ativar NRT não muda o comportamento do código em runtime, só adiciona análise na compilação.
- Código antigo pode mostrar um monte de avisos logo de cara.
- Se você usa libs sem anotações NRT, o compilador vai ser cauteloso e assumir que tudo pode ser null.
GO TO FULL VERSION