Compartilhar via

?? e os operadores ?? = - os operadores de união nula

  • Artigo

O operador de coalescência nula ?? retornará o valor do operando esquerdo se não for null; caso contrário, ele avaliará o operando direito e retornará seu resultado. O operador ?? não avaliará o operando do lado direito se o operando esquerdo for avaliado como não nulo. O operador de atribuição de avaliação de nulo ??= atribuirá o valor do operando do lado direito para o operando esquerdo somente se o operando esquerdo for avaliado como null. O operador ??= não avaliará o operando do lado direito se o operando esquerdo 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 à esquerda do operador ??= deve ser uma variável, uma propriedade ou um elemento indexador.

O tipo do operando à esquerda dos ?? e ??= operadores não pode ser um tipo de valor não anulável. Em particular, você pode usar os operadores de avaliação de nulo com parâmetros de tipo não treinados:

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

Os operadores de avaliação de nulo são associativos à direita. Ou seja, expressões do formulário

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

são avaliadas como

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

Exemplos

Os operadores ?? e ??= podem ser úteis nos seguintes cenários:

  • Em expressões com os operadores condicionais nulos ?. e ?[], você pode usar o ?? operador para fornecer uma expressão alternativa a ser avaliada caso o resultado da expressão com operação condicional nula seja 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 você trabalhar com tipos que permitem valor nulo e precisar fornecer o valor de um tipo subjacente, use o operador ?? para especificar o valor a ser fornecido caso o tipo que permite valor nulo seja null:

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

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

  • Você pode usar uma expressão throw como o operando direito do operador ?? para tornar o código de verificação de argumento mais conciso:

    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 aptos para expressão para definir uma propriedade.

  • Você pode usar o operador ??= para substituir o código do formulário

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

    pelo código a seguir:

    variable ??= expression;

Capacidade de sobrecarga do operador

Os operadores ?? e ??= não podem ser sobrecarregados.

Especificação da linguagem C#

Para obter mais informações sobre o operador ??, consulte a seção O operador de avaliação de nulo da Especificação da linguagem c#.

Para obter mais informações sobre o operador ??=, confira a nota da proposta do recurso.

Confira também