Freigeben über

?? und ??=: die NULL-Sammeloperatoren

  • Artikel

Der NULL-Zusammenfügungsoperator ?? gibt den Wert des linken Operanden zurück, wenn dieser nicht null ist. Andernfalls wertet der Operator den rechten Operanden aus und gibt dessen Ergebnis zurück. Der ??-Operator wertet seinen rechten Operanden nicht aus, wenn der linke Operand auf einen Wert ungleich NULL ausgewertet wird. Der NULL-Sammeloperator für die Zuweisung ??= weist den Wert seines rechten Operanden dem linken Operanden nur zu, wenn der linke Operand zu null ausgewertet wird. Der ??=-Operator wertet seinen rechten Operanden nicht aus, wenn der linke Operand auf einen Wert ungleich NULL ausgewertet wird.

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

Der linke Operand des ??=-Operators muss eine Variable, eine Eigenschaft oder ein Indexer-Element sein.

Der Typ des linken Operanden der Operatoren ?? und ??= kann kein Non-Nullable-Werttyp sein. Das heißt, Sie können die NULL-Sammeloperatoren mit uneingeschränkten Typparametern verwenden:

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

Die NULL-Sammeloperatoren sind rechtsassoziativ. Das heißt, Ausdrücke wie

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

werden wie folgt ausgewertet

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

Beispiele

Die Operatoren ?? und ??= können in folgenden Szenarios nützlich sein:

  • In Ausdrücken mit den NULL-Bedingungsoperatoren ?. und ?[] können Sie den ??-Operator verwenden, um einen alternativen Ausdruck zum Auswerten für den Fall bereitzustellen, dass das Ergebnis des Vorgangs mit NULL-Bedingung null ist:

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

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

  • Wenn Sie mit Nullable-Werttypen arbeiten und den Wert eines zugrunde liegenden Werttyps bereitstellen müssen, verwenden Sie den ??-Operator, um den Wert für den Fall anzugeben, dass der Wert eines Nullable-Typs null ist:

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

    Verwenden Sie die Nullable<T>.GetValueOrDefault()-Methode, wenn der Wert, der verwenden werden soll, falls der Wert des Nullable-Typs null lautet, der Standardwert des zugrunde liegenden Werttyps sein soll.

  • Sie können einen throw-Ausdruck als rechten Operanden des ??-Operators verwenden, um den Code für die Argumentüberprüfung kürzer zu fassen:

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

    Das oben stehende Beispiel veranschaulicht auch, wie Sie Ausdruckskörpermember verwenden, um eine Eigenschaft zu definieren.

  • Mit dem ??=-Operator ersetzen Sie diesen Code

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

    durch den folgenden Code:

    variable ??= expression;

Operatorüberladbarkeit

Die Operatoren ?? und ??= können nicht überladen werden.

C#-Sprachspezifikation

Weitere Informationen über den ??-Operator finden Sie im Abschnitt NULL-Sammeloperatoren der C#-Sprachspezifikation.

Weitere Informationen zum ??=-Operator finden Sie unter Hinweis zum Featurevorschlag.

Weitere Informationen