C# Language
Opérateurs Null-Conditionnels

Syntaxe

• X? .Y; // null si X est nul sinon XY
• X? .Y? .Z; // null si X est nul ou Y est nul sinon XYZ
• X? [Index]; // null si X est nul sinon X [index]
• X? .ValueMethod (); // null si X est nul sinon le résultat de X.ValueMethod ();
• X? .VoidMethod (); // ne fait rien si X est nul sinon appelle X.VoidMethod ();

Remarques

Opérateur Null-Conditionnel

Le ?. l'opérateur est le sucre syntaxique pour éviter les vérifications nulles verbeuses. Il est également connu sous le nom de l' opérateur de navigation sécurisé .

Classe utilisée dans l'exemple suivant:

public class Person
{
    public int Age { get; set; }
    public string Name { get; set; }
    public Person Spouse { get; set; }
}

Si un objet est potentiellement nul (comme une fonction renvoyant un type de référence), l'objet doit d'abord être vérifié pour la valeur null afin d'éviter une éventuelle NullReferenceException . Sans l'opérateur null-conditionnel, cela ressemblerait à ceci:

Person person = GetPerson();

int? age = null;
if (person != null)
    age = person.Age;

Le même exemple en utilisant l'opérateur null-conditionnel:

Person person = GetPerson();

var age = person?.Age;    // 'age' will be of type 'int?', even if 'person' is not null

Enchaînement de l'opérateur

L'opérateur conditionnel null peut être combiné sur les membres et sous-membres d'un objet.

// Will be null if either `person` or `person.Spouse` are null
int? spouseAge = person?.Spouse?.Age;

Combinaison avec l'opérateur de coalescence nulle

L'opérateur null-conditionnel peut être combiné avec l' opérateur null-coalescing pour fournir une valeur par défaut:

// spouseDisplayName will be "N/A" if person, Spouse, or Name is null
var spouseDisplayName = person?.Spouse?.Name ?? "N/A";

L'indice Null-Conditionnel

De même que le ?. opérateur, l'opérateur d'index null-conditionnel vérifie les valeurs NULL lors de l'indexation dans une collection pouvant être nulle.

string item = collection?[index];

est le sucre syntaxique pour

string item = null;
if(collection != null)
{
    item = collection[index];
}

Éviter les NullReferenceExceptions

var person = new Person
{
    Address = null;
};

var city = person.Address.City; //throws a NullReferenceException
var nullableCity = person.Address?.City; //returns the value of null

Cet effet peut être enchaîné:

var person = new Person
{
    Address = new Address
    {
        State = new State
        {
            Country = null
        }
    }
};

// this will always return a value of at least "null" to be stored instead
// of throwing a NullReferenceException
var countryName = person?.Address?.State?.Country?.Name; 

L'opérateur Null-conditionnel peut être utilisé avec la méthode d'extension

La méthode d'extension peut fonctionner sur des références nulles , mais vous pouvez utiliser ?. pour annuler la vérification de toute façon.

public class Person 
{
    public string Name {get; set;}
}

public static class PersonExtensions
{
    public static int GetNameLength(this Person person)
    {
        return person == null ? -1 : person.Name.Length;
    }
}

Normalement, la méthode sera déclenchée pour null références null et retournera -1:

Person person = null;
int nameLength = person.GetNameLength(); // returns -1

En utilisant ?. la méthode ne sera pas déclenchée pour null références null , et le type est int? :

Person person = null;
int? nameLength = person?.GetNameLength(); // nameLength is null.

Ce comportement est en fait attendu de la façon dont le ?. L'opérateur fonctionne: il évitera de faire des appels de méthode d'instance pour des instances NULL, afin d'éviter les NullReferenceExceptions . Cependant, la même logique s’applique à la méthode d’extension, malgré la différence sur la manière dont la méthode est déclarée.

Pour plus d'informations sur la raison pour laquelle la méthode d'extension est appelée dans le premier exemple, reportez-vous à la documentation relative aux méthodes d'extension - null .