Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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 warnings

Os 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 restore

Resultado

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.

Fontes