Opérateur Null-Conditionnel en C#

Explication rapide grâce à la page Docs

Gerald commence par se référer à la documentation officielle de Microsoft sur les opérateurs et expressions d'accès des membres. Il met en avant la section concernant l'opérateur conditionnel null, introduit dans C# 6. Au moment de l'enregistrement, C# 9 était la dernière version, avec C# 10 à l'horizon.

Gerald explique que lorsque vous utilisez a?.x ou a?[index], si a est null, l'expression entière est évaluée à null au lieu de lancer une NullReferenceException. Dans le cas contraire, elle récupère la valeur normalement.

Bien que la documentation soit utile, Gerald préfère les exemples pratiques, il passe donc à un environnement de codage interactif.

Exemple à travers try.dot.net

Pour la démonstration, Gerald passe à try.dot.net, un environnement C# interactif. Il mentionne que cet outil fonctionne sur Blazor, permettant aux utilisateurs d'exécuter du code C# directement dans un navigateur.

Il montre brièvement l'exemple par défaut de la séquence de Fibonacci, qui est préchargé dans try.dot.net, puis l'efface pour commencer un nouvel exemple axé sur l'opérateur conditionnel nul.

Explication des opérateurs inconditionnels

Gerald crée une classe Personne simple avec les propriétés suivantes :

public class Person
{
    // The Name property of the Person
    public string Name { get; set; }

    // A reference to another Person object representing the partner
    public Person Partner { get; set; }

    // An array representing the Person's hobbies
    public string[] Hobbies { get; set; }
}

public class Person
{
    // The Name property of the Person
    public string Name { get; set; }

    // A reference to another Person object representing the partner
    public Person Partner { get; set; }

    // An array representing the Person's hobbies
    public string[] Hobbies { get; set; }
}

Il initialise un objet Person comme null :

// Initialize a Person object as null
Person person = null;

// Attempting to access a property of a null object will throw a NullReferenceException
Console.WriteLine(person.Name);

// Initialize a Person object as null
Person person = null;

// Attempting to access a property of a null object will throw a NullReferenceException
Console.WriteLine(person.Name);

L'exécution de ce code lance une NullReferenceException car person est null. Pour éviter cela, les développeurs ajoutent généralement une vérification de nullité avant d'accéder aux propriétés :

// Check if the person object is not null before accessing its properties
if (person != null)
{
    Console.WriteLine(person.Name);
}

// Check if the person object is not null before accessing its properties
if (person != null)
{
    Console.WriteLine(person.Name);
}

Cette méthode fonctionne, mais elle introduit des lignes de code supplémentaires. Gerald explique comment l'opérateur null-conditional simplifie cette tâche :

// Using the null-conditional operator to safely access the Name property
Console.WriteLine(person?.Name);

// Using the null-conditional operator to safely access the Name property
Console.WriteLine(person?.Name);

Maintenant, si person est null, l'expression renvoie simplement null au lieu de planter.

Opérateur inconditionnel sur les propriétés

Gerald développe l'exemple en configurant un objet Person :

// Create a new Person object
Person person = new Person { Name = "Gerald" };

// Access the Name property safely
Console.WriteLine(person?.Name);

// Create a new Person object
Person person = new Person { Name = "Gerald" };

// Access the Name property safely
Console.WriteLine(person?.Name);

Puisque person n'est pas null, il affiche correctement "Gerald".

Il montre ensuite un exemple imbriqué :

// Safely access the Name property of the Partner object
Console.WriteLine(person?.Partner?.Name);

// Safely access the Name property of the Partner object
Console.WriteLine(person?.Partner?.Name);

Si person.Partner est null, l'expression entière est évaluée à null au lieu de lancer une exception. Cela permet d'éviter les conditions inutiles.

Chaîner des opérateurs Null-Conditional

Gerald explique que les opérateurs conditionnels nuls peuvent être enchaînés, ce qui rend le code plus propre lorsqu'il s'agit d'objets profondément imbriqués. Au lieu d'écrire plusieurs vérifications de nullité, vous pouvez utiliser :

// Chain null-conditional operators to safely access nested objects
Console.WriteLine(person?.Partner?.Name);

// Chain null-conditional operators to safely access nested objects
Console.WriteLine(person?.Partner?.Name);

Si person ou person.Partner est null, le résultat sera null, évitant ainsi les erreurs d'exécution.

Opérateurs inconditionnels sur les tableaux

Gerald étend la discussion aux arrays et collections. Il ajoute un tableau Hobbies à la classe Person et montre comment accéder aux éléments en toute sécurité :

// Safely access the first element of the Hobbies array
Console.WriteLine(person?.Hobbies?[0]);

// Safely access the first element of the Hobbies array
Console.WriteLine(person?.Hobbies?[0]);

Ici, si person ou Hobbies est null, l'expression est évaluée à null au lieu de causer une exception.

Conclusion

La vidéo de Gerald offre un aperçu approfondi de l'opérateur conditionnel null dans C#. En utilisant ?. et ?[ ], les développeurs peuvent écrire un code plus propre et plus sûr qui évite les NullReferenceException. Qu'il s'agisse de propriétés, d'objets imbriqués ou de tableaux, l'opérateur null-conditional rend le code plus concis et plus lisible.

Pour une démonstration complète, ne manquez pas de regarder la vidéo de Gerald Versluis où il explique tout à l'aide d'exemples pratiques !