C# Language
Opérateur de coalescence nulle

Syntaxe

• var result = possibleNullObject ?? valeur par défaut;

Paramètres

Remarques

possibleNullObject != null ? possibleNullObject : defaultValue

Utilisation de base

L'utilisation de l' null-coalescing operator (??) vous permet de spécifier une valeur par défaut pour un type nullable si l'opérande de gauche est null .

string testString = null;
Console.WriteLine("The specified string is - " + (testString ?? "not provided"));

Démo en direct sur .NET Fiddle

Ceci est logiquement équivalent à:

string testString = null;
if (testString == null)
{
    Console.WriteLine("The specified string is - not provided");
}
else
{
    Console.WriteLine("The specified string is - " + testString);
}

ou en utilisant l' opérateur ternary (? :) :

string testString = null;
Console.WriteLine("The specified string is - " + (testString == null ? "not provided" : testString));

Null fall-through et chaining

L'opérande de gauche doit être nul, tandis que l'opérande de droite peut l'être ou non. Le résultat sera saisi en conséquence.

Non nullable

int? a = null;
int b = 3;
var output = a ?? b;
var type = output.GetType();  

Console.WriteLine($"Output Type :{type}");
Console.WriteLine($"Output value :{output}");

Sortie:

Type: System.Int32
valeur: 3

Voir la démo

Nullable

int? a = null;
int? b = null;
var output = a ?? b;

output sera de type int? et égal à b ou null .

Coalescence Multiple

La coalescence peut également être effectuée en chaînes:

int? a = null;
int? b = null;
int c = 3;
var output = a ?? b ?? c;

var type = output.GetType();    
Console.WriteLine($"Type :{type}");
Console.WriteLine($"value :{output}");

Sortie:

Type: System.Int32
valeur: 3

Voir la démo

Chaînage conditionnel nul

L'opérateur de coalescence nulle peut être utilisé en parallèle avec l' opérateur de propagation nul pour fournir un accès plus sûr aux propriétés des objets.

object o = null;
var output = o?.ToString() ?? "Default Value";

Sortie:

Type: System.String
valeur: valeur par défaut

Voir la démo

Opérateur de coalescence null avec appels de méthode

L'opérateur de coalescence null permet de s'assurer qu'une méthode pouvant renvoyer une valeur null revient à une valeur par défaut.

Sans l'opérateur de coalescence nulle:

string name = GetName();

if (name == null)
    name = "Unknown!";

Avec l'opérateur de coalescence null:

string name = GetName() ?? "Unknown!";

Utiliser existant ou créer de nouvelles

Un scénario d'utilisation courant avec lequel cette fonctionnalité aide vraiment est lorsque vous recherchez un objet dans une collection et que vous devez en créer un s'il n'existe pas déjà.

IEnumerable<MyClass> myList = GetMyList();
var item = myList.SingleOrDefault(x => x.Id == 2) ?? new MyClass { Id = 2 };

Initialisation des propriétés paresseuses avec un opérateur de coalescence nul

private List<FooBar> _fooBars;

public List<FooBar> FooBars
{
    get { return _fooBars ?? (_fooBars = new List<FooBar>()); }
}

La première fois que la propriété .FooBars est accessible à la _fooBars variable d' évaluer comme null , tombant ainsi à travers à la déclaration d' affectation attribue et évalue à la valeur résultante.

Fil de sécurité

Ce n'est pas un moyen sûr d'utiliser des propriétés paresseuses. Pour la paresse thread-safe, utilisez la classe Lazy<T> intégrée au .NET Framework.

C # 6 Sugar Syntactic utilisant des corps d'expression

Notez que depuis C # 6, cette syntaxe peut être simplifiée en utilisant le corps de l'expression pour la propriété:

private List<FooBar> _fooBars;

public List<FooBar> FooBars => _fooBars ?? ( _fooBars = new List<FooBar>() );

Les accès ultérieurs à la propriété donneront la valeur stockée dans la variable _fooBars .

Exemple dans le pattern MVVM

Ceci est souvent utilisé lors de l'implémentation de commandes dans le modèle MVVM. Au lieu d'initialiser les commandes avec empressement avec la construction d'un modèle de vue, les commandes sont initialisées paresseusement en utilisant ce modèle comme suit:

private ICommand _actionCommand = null;
public ICommand ActionCommand =>
   _actionCommand ?? ( _actionCommand = new DelegateCommand( DoAction ) );