Partilhar via

?? e ??= operadores - os operadores de coalescência nula

O operador ?? de coalescência nula devolve o valor do seu operando da esquerda se não nullfor . Caso contrário, ele avalia o operando direito e retorna seu resultado. O operador ?? não avalia o operando à direita se o operando à esquerda for avaliado como não nulo. O operador ??= de atribuição de coalescência nula atribui o valor de seu operando direito ao operando esquerdo somente se o operando esquerdo for avaliado como null. O operador ??= não avalia o operando à direita se o operando à esquerda for avaliado como não nulo.

List<int>? numbers = null;
int? a = null;

Console.WriteLine((numbers is null)); // expected: true
// if numbers is null, initialize it. Then, add 5 to numbers
(numbers ??= new List<int>()).Add(5);
Console.WriteLine(string.Join(" ", numbers));  // output: 5
Console.WriteLine((numbers is null)); // expected: false        


Console.WriteLine((a is null)); // expected: true
Console.WriteLine((a ?? 3)); // expected: 3 since a is still null 
// if a is null then assign 0 to a and add a to the list
numbers.Add(a ??= 0);
Console.WriteLine((a is null)); // expected: false        
Console.WriteLine(string.Join(" ", numbers));  // output: 5 0
Console.WriteLine(a);  // output: 0

O operando esquerdo do ??= operador deve ser uma variável, uma propriedade ou um elemento indexador .

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#.

O tipo do operando esquerdo dos operadores ?? e ??= não pode ser um tipo de valor não-nulo. Em particular, você pode usar os operadores de coalescência nula com parâmetros de tipo sem restrições:

private static void Display<T>(T a, T backup)
{
    Console.WriteLine(a ?? backup);
}

Os operadores de coalescência nula são associativos à direita. Ou seja, expressões da forma

a ?? b ?? c
d ??= e ??= f

são avaliados como

a ?? (b ?? c)
d ??= (e ??= f)

Exemplos

Os ?? operadores e ??= são úteis nos seguintes cenários:

  • Em expressões que utilizam os operadores ?. nulo-condicionais e ?[], usa o ?? operador para fornecer uma expressão alternativa para avaliar se o resultado da expressão com operações nulos-condicionais é null:

    double SumNumbers(List<double[]> setsOfNumbers, int indexOfSetToSum)
{
    return setsOfNumbers?[indexOfSetToSum]?.Sum() ?? double.NaN;
}

var sum = SumNumbers(null, 0);
Console.WriteLine(sum);  // output: NaN

  • Quando trabalha com tipos de valor nulo e precisa de fornecer um valor de um tipo subjacente, use o ?? operador para especificar o valor a fornecer se o valor do tipo nulo for null:

    int? a = null;
int b = a ?? -1;
Console.WriteLine(b);  // output: -1

    Use o Nullable<T>.GetValueOrDefault() método se o valor a usar quando um valor do tipo nulo for null for deve ser o valor padrão do tipo de valor subjacente.

  • Para tornar o código de verificação de argumentos mais conciso, use uma throw expressão como operando à direita do ?? operador:

    public string Name
{
    get => name;
    set => name = value ?? throw new ArgumentNullException(nameof(value), "Name cannot be null");
}

    O exemplo anterior também demonstra como usar membros com corpo de expressão para definir uma propriedade.

  • Use o ??= operador para substituir o código da seguinte forma:

    if (variable is null)
{
    variable = expression;
}

    Utilize o seguinte código:

    variable ??= expression;

Capacidade de sobrecarga do operador

Não podes sobrecarregar os ?? operadores de AND ??= .

Especificação da linguagem C#

Para obter mais informações sobre o ?? operador, consulte a seção O operador de coalescência nulo da especificação da linguagem C#.

Para obter mais informações sobre o ??= operador, consulte a seção Atribuição composta da especificação da linguagem C#.

Ver também

  • Last updated on