Partager via

?? Opérateurs ??=, opérateurs de coalescence nulle

L’opérateur de coalescence nulle ?? retourne la valeur de son opérande de gauche s'il n'est pas nullnull ; sinon, il évalue l’opérande de droite et retourne son résultat. L’opérateur ?? n’évalue pas son opérande droit si l’opérande gauche a la valeur non Null. L’opérateur de coalescence nulle ??= assigne la valeur de son opérande droit à son opérande gauche uniquement si l’opérande gauche a la valeur null. L’opérateur ??= n’évalue pas son opérande droit si l’opérande gauche a la valeur non Null.

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

L’opérande de gauche de l’opérateur ??= doit être une variable, une propriété ou un élément d’indexeur .

Le type de l’opérande du côté gauche des opérateurs ?? et ??= ne peut pas être un type valeur non nullable. En particulier, vous pouvez utiliser les opérateurs de coalescence nulle avec des paramètres de type non contraints :

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

Les opérateurs de coalescence nulle sont associatifs de droite. Autrement dit, les expressions du formulaire

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

sont évalués en tant que

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

Exemples

Les opérateurs ?? et ??= peuvent être utiles dans les scénarios suivants :

  • Dans les expressions avec les opérateurs conditionnels null?. et ?[], vous pouvez utiliser l’opérateur ?? pour fournir une autre expression à évaluer si le résultat de l’expression avec des opérations conditionnelles null est null :

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

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

  • Lorsque vous utilisez des types valeur nullables et que vous devez fournir une valeur d’un type valeur sous-jacent, utilisez l’opérateur ?? pour spécifier la valeur à fournir au cas où une valeur de type Nullable était null:

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

    Utilisez la Nullable<T>.GetValueOrDefault() méthode si la valeur à utiliser lorsqu’une valeur de type Nullable doit null être la valeur par défaut du type valeur sous-jacente.

  • Vous pouvez utiliser une throw expression comme opérande de droite de l’opérateur ?? pour rendre le code de vérification des arguments plus concis :

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

    L’exemple précédent montre également comment utiliser des membres à corps d'expression pour définir une propriété.

  • Vous pouvez utiliser l’opérateur ??= pour remplacer le code du formulaire

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

    avec le code suivant :

    variable ??= expression;

Surcharge des opérateurs

Les opérateurs ?? et ??= ne peuvent pas être surchargés.

Spécification du langage C#

Pour plus d’informations sur l’opérateur ?? , consultez la section Opérateur de fusion Null de la spécification du langage C#.

Pour plus d’informations sur l’opérateur ??= , consultez la note de proposition de fonctionnalité.

Voir aussi