Partilhar via

! Operador (null-forgiving) (referência C#)

O operador postfix ! unário é o operador null-forgiving, ou null-suppression. Num contexto de anotação nula ativada, use o operador nulo de perdão para suprimir todos os avisos anuláveis da expressão anterior. O operador de prefixo ! unário é o operador de negação lógica. O operador de tolerância nula não tem efeito em tempo de execução. Ele afeta apenas a análise de fluxo estático do compilador alterando o estado nulo da expressão. Em tempo de execução, a expressão x! é avaliada como o resultado da expressão xsubjacente.

Para obter mais informações sobre o recurso de tipos de referência anuláveis, consulte Tipos de referência anuláveis.

A referência da linguagem C# documenta a versão mais recentemente lançada da linguagem C#. Contém também documentação inicial para funcionalidades em versões preliminares públicas para a próxima versão da linguagem.

A documentação identifica qualquer funcionalidade introduzida pela primeira vez nas últimas três versões da língua ou em pré-visualizações públicas atuais.

Sugestão

Para saber quando uma funcionalidade foi introduzida pela primeira vez em C#, consulte o artigo sobre o histórico de versões da linguagem C#.

Exemplos

Um caso de uso para o operador de perdão nulo é testar a lógica de validação de argumentos. Por exemplo, considere a seguinte classe:

#nullable enable
public class Person
{
    public Person(string name) => Name = name ?? throw new ArgumentNullException(nameof(name));

    public string Name { get; }
}

Ao usar o framework de teste MSTest, pode criar o seguinte teste para a lógica de validação no construtor:

[TestMethod, ExpectedException(typeof(ArgumentNullException))]
public void NullNameShouldThrowTest()
{
    var person = new Person(null!);
}

Sem o operador null-forpering, o compilador gera o seguinte aviso para o código anterior: Warning CS8625: Cannot convert null literal to non-nullable reference type. Ao usar o operador null-perdoando, informa o compilador que o passing null é esperado e não deve gerar um aviso.

Também podes usar o operador null-perdoando quando sabes perfeitamente que uma expressão não pode existir null , mas o compilador não reconhece isso. No exemplo a seguir, se o IsValid método retornar true, seu argumento não null é e você pode desreferenciar com segurança:

public static void Main()
{
    Person? p = Find("John");
    if (IsValid(p))
    {
        Console.WriteLine($"Found {p!.Name}");
    }
}

public static bool IsValid(Person? person)
    => person is not null && person.Name is not null;

Sem o operador null-forper, o compilador gera o seguinte aviso para o p.Name código: Warning CS8602: Dereference of a possibly null reference.

Se você pode modificar o IsValid método, você pode usar o atributo NotNullWhen para informar o compilador que um argumento do IsValid método não pode ser null quando o método retorna true:

public static void Main()
{
    Person? p = Find("John");
    if (IsValid(p))
    {
        Console.WriteLine($"Found {p.Name}");
    }
}

public static bool IsValid([NotNullWhen(true)] Person? person)
    => person is not null && person.Name is not null;

No exemplo anterior, você não precisa usar o operador null-forgiving porque o compilador tem informações suficientes para descobrir que p não pode estar null dentro da if instrução. Para obter mais informações sobre os atributos que permitem fornecer informações adicionais sobre o estado nulo de uma variável, consulte Atualizar APIs com atributos para definir expectativas nulas.

Especificação da linguagem C#

Para obter mais informações, consulte a seção O operador de tolerância nula do rascunho da especificação de tipos de referência anuláveis.

Consulte também

  • Last updated on