CKTIS / C#
Tipos de referência anuláveis e contexto #nullable
As anotações string e string? exprimem a intenção relativamente a null, enquanto a análise de fluxo do compilador alerta para utilizações inseguras. O contexto #nullable controla as anotações e os avisos de forma independente; não acrescenta verificações em tempo de execução.
Versão: .NET 10; repository net10.0 and LangVersion=preview; feature versions require per-entry verification
Sintaxe
T value;
T? optional;
#nullable enable
#nullable disable
#nullable restore
#nullable enable annotations
#nullable disable warnings
#nullable restore warningsOs tipos de referência anuláveis foram introduzidos no C# 8.0 e não requerem o modo preview num projeto .NET 10. Com as anotações ativadas, string indica uma referência que, segundo a intenção, não deverá ser null, enquanto string? permite explicitamente null. Ambos anotam o mesmo tipo em tempo de execução; não equivalem a Nullable<T> para tipos de valor, como int?.
O compilador distingue a anotação declarada de um valor do seu estado de nulabilidade na análise de fluxo. À entrada de um método, com base nas anotações, o compilador considera normalmente que um parâmetro string não é null e que um parâmetro string? pode ser null. Este estado pode mudar ao longo da análise de fluxo. O compilador emite um aviso quando um possível null é atribuído a uma referência não anulável ou quando uma referência possivelmente nula é desreferenciada, por exemplo através de text.Length. Depois de verificar text is null e sair desse ramo, a análise reconhece que a utilização seguinte de text é segura. O operador text! apenas altera a avaliação do compilador: não verifica o valor nem impede NullReferenceException.
A definição do projeto <Nullable>enable</Nullable> ativa as anotações e os avisos. disable desativa ambos, annotations ativa apenas as anotações e warnings apenas os avisos. Com as anotações desativadas, as referências sem ? não são acompanhadas quanto à nulabilidade, e a utilização de ? pode gerar um aviso.
As diretivas #nullable enable e #nullable disable substituem as definições para as linhas seguintes do ficheiro. #nullable restore repõe as definições do projeto, não a diretiva anterior. Um alvo opcional, annotations ou warnings, como em #nullable disable warnings, altera apenas essa opção. O efeito mantém-se até outra diretiva aplicável ou até ao fim do ficheiro.
Isto é uma ajuda em tempo de compilação, não uma garantia contra null em tempo de execução. Por exemplo, new string[3] contém inicialmente elementos null, apesar do tipo string[]. Corrige o fluxo de dados e verifica os valores em vez de suprimir avisos às cegas com !.
Identificadores de referência abrangidos por esta entrada: Nullable reference annotations and #nullable context.
Exemplos
#nullable enable
using System;
internal static class Program
{
private static void Main()
{
PrintLength(null);
PrintLength("Ada");
}
private static void PrintLength(string? text)
{
if (text is null)
{
Console.WriteLine("missing");
return;
}
Console.WriteLine(text.Length);
}
}
#nullable restoreResultado
missing 3
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.