Considérez le scénario typique suivant:

if(myObject == null) {
    myObject = new myClass();
}

Je me demande ce que l'on pense du remplacement suivant en utilisant l'opérateur de coalescence nulle:

myObject = myObject ?? new myClass();

Je ne sais pas si je devrais utiliser le deuxième formulaire. Cela semble être un joli raccourci, mais la myObject = myObjectconstruction au début semble pouvoir ressembler à une odeur de code.

Est-ce une chose raisonnable à faire ou y a-t-il un meilleur raccourci qui me manque? Ou peut-être, "c'est trois lignes, surmontez-le!"?

Edit: Comme cela a été mentionné, peut-être appeler cela un scénario typique est quelque chose d'une surestimation. Je trouve généralement que je rencontre cette situation lorsque je récupère une entité d'une base de données qui possède une propriété de type de référence enfant qui peut ou non encore être remplie:

myClass myObject = myClassService.getById(id);
myObject.myChildObject = myObject.myChildObject ?? new myChildClass();

J'utilise toujours l'opérateur de coalescence nulle. J'aime sa concision.

Je trouve que cet opérateur est de nature similaire à l'opérateur ternaire (A? B: C). Il faut un peu de pratique avant que la lecture soit une seconde nature, mais une fois que vous y êtes habitué, je pense que la lisibilité s'améliore par rapport aux versions longues.

De plus, la situation que vous décrivez n'est qu'un scénario dans lequel l'opérateur est utile. Il est également pratique de remplacer des constructions comme celle-ci:

if (value != null)
{
    return value;
}
else
{ 
    return otherValue;
}

ou

return value != null ? value : otherValue;

avec

return value ?? otherValue;

Ce que je me demande précisément, c'est d'utiliser l'opérateur pour définir un objet sur lui-même, sauf s'il est nul.

Le ?? operatorest appelé l'opérateur de coalescence nulle et est utilisé pour définir une valeur par défaut pour les types de valeur nullable ou les types de référence. Il renvoie l'opérande de gauche si l'opérande n'est pas nul; sinon, elle renvoie l'opérande de droite.

myObject = myObject ?? new myObject(); - instantiate default value of object

Plus de détails et exemple de code sur l'opérateur de coalescence nulle - article MSDN .

Si vous vérifiez l' more than nullableétat, comme solution de rechange , vous pouvez utiliser l' opérateur ternaires.

Opérateur ternaire

Vous pouvez également consulter ?: Opérateur . Il est appelé opérateur ternaire ou conditionnel . L'opérateur conditionnel (? :) renvoie l'une des deux valeurs en fonction de la valeur d'une expression booléenne.

Un type nullable peut contenir une valeur, ou il peut être indéfini. Le ?? L'opérateur définit la valeur par défaut à renvoyer lorsqu'un type nullable est affecté à un type non nullable. Si vous essayez d'affecter un type de valeur nullable à un type de valeur non nullable sans utiliser le ?? , vous générerez une erreur de compilation. Si vous utilisez un transtypage et que le type de valeur nullable n'est actuellement pas défini, une exception InvalidOperationException sera levée.

Un exemple de code de MSDN -?: Opérateur (référence C #) :

int? input = Convert.ToInt32(Console.ReadLine());
string classify;

// ?: conditional operator.
classify = (input.HasValue) ? ((input < 0) ? "negative" : "positive") : "undefined";

Je ne pense pas que ce scénario soit (ou du moins devrait être) typique.

Si vous souhaitez que la valeur par défaut de certains champs ne soit pas null, définissez-la dans l'initialiseur de champs:

myClass myObject = new myClass();

Ou, si l'initialisation est plus compliquée, définissez-la dans le constructeur.

Si vous souhaitez créer myClassuniquement lorsque vous en avez réellement besoin (par exemple, car sa création prend beaucoup de temps), vous pouvez utiliser Lazy<T>:

Lazy<myClass> myObject = new Lazy<myClass>();

(Cela appelle le constructeur par défaut. Si l'initialisation est plus compliquée, passez lambda qui crée myClassau Lazy<T>constructeur.)

Pour accéder à la valeur, utilisez myObject.Value, qui appellera l'initialisation si c'est la première fois que vous accédez myObject.Value.

J'aime particulièrement utiliser ??en conjonction avec des paramètres de méthode facultatifs. Je limite le besoin de surcharges et m'assure que la chose a une valeur.

public void DoSomething (MyClass thing1 = null) {
    thing1 = thing1 ?? new MyClass();
}