Comprendre l'opérateur de fusion Null en C#

L'opérateur de coalescence des zéros ( ??) en C# permet aux développeurs de simplifier la logique de vérification des zéros, ce qui réduit la verbosité du code et améliore la lisibilité. Au lieu d'écrire de longues conditions if-else, cet opérateur fournit un moyen concis d'assigner des valeurs de repli lorsque l'on rencontre null. Dans cet article, nous allons explorer en détail l'opérateur de coalescence null en suivant la vidéo de Gerald Versluis, "Understanding C# Null Coalescing Operator ( ?? et ??=)." Nous allons décomposer les sections clés de la vidéo et analyser la manière dont Gerald démontre cette fonctionnalité utile du C#.

Introduction

Au début de la vidéo, Gerald présente l'opérateur de coalescence des nullités comme une fonctionnalité puissante de C# qui réduit considérablement le nombre de lignes de code nécessaires à la vérification des nullités. Il souligne que cet opérateur simplifie les vérifications conditionnelles et rend le code plus lisible. Pour illustrer ses avantages, Gerald présente un exemple d'application dans lequel il met en œuvre et explique divers cas d'utilisation de l'opérateur de coalescence nulle.

Schéma d'un exemple d'application

Gerald commence par mettre en place une application console simple. Il mentionne que, dans les vidéos précédentes, il a utilisé le site web try.dot.net pour les démonstrations, mais qu'en raison des limitations de version (prise en charge de C# 7 uniquement), il passe à Visual Studio pour Mac. Il assure que les exemples fonctionneront également avec Visual Studio pour Windows.

Pour préparer la démonstration, Gérald crée une classe de base Person avec une seule propriété Name :

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

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

Public Class Person
    Public Property Name As String
End Class

Public Class Person
    Public Property Name As String
End Class

Il initialise ensuite une instance de cette classe pour montrer comment l'opérateur de coalescence null fonctionne dans des scénarios réels.

Remplacer la vérification de la nullité par l'opérateur de fusion de la nullité ( ??)

Gerald montre maintenant comment l'opérateur de coalescence des zéros ( ??) peut être utilisé pour simplifier la logique de vérification des zéros. Il assigne la valeur null à la propriété Name puis utilise ?? pour fournir une valeur de repli :

var name = person.Name ?? "Gerald";

var name = person.Name ?? "Gerald";

Dim name As String = If(person.Name, "Gerald")

Dim name As String = If(person.Name, "Gerald")

Gerald explique qu'avant cet opérateur, les développeurs utilisaient une instruction if :

string name;
if (person.Name == null)
{
    name = "Gerald";
}
else
{
    name = person.Name;
}

string name;
if (person.Name == null)
{
    name = "Gerald";
}
else
{
    name = person.Name;
}

Dim name As String
If person.Name Is Nothing Then
    name = "Gerald"
Else
    name = person.Name
End If

Dim name As String
If person.Name Is Nothing Then
    name = "Gerald"
Else
    name = person.Name
End If

En utilisant ??, cette logique est réduite à une seule ligne. Lorsque person.Name est null, " Gérald " est assigné ; sinon, person.Name conserve sa valeur. Il exécute le programme et confirme que le résultat est correct.

Null-Coalescing to Throw Exceptions (en anglais)

Ensuite, Gerald explore un autre cas d'utilisation : le lancement d'exceptions à l'aide de l'opérateur de coalescence null. Au lieu de fournir une valeur de repli, il montre comment lancer une exception lorsqu'il rencontre null :

var name = person.Name ?? throw new ArgumentNullException(nameof(person.Name), "Name cannot be null");

var name = person.Name ?? throw new ArgumentNullException(nameof(person.Name), "Name cannot be null");

Dim name As String = If(person.Name, Throw New ArgumentNullException(NameOf(person.Name), "Name cannot be null"))

Dim name As String = If(person.Name, Throw New ArgumentNullException(NameOf(person.Name), "Name cannot be null"))

Gerald souligne que ces outils sont particulièrement utiles lorsqu'il s'agit de travailler avec des paramètres de méthode ou des propriétés pour lesquels la valeur null ne devrait pas être autorisée. Il explique que cette fonctionnalité a été introduite dans C# 7 ou 8, selon les paramètres du projet. Exécuter le code avec une valeur null pour person.Name entraîne un ArgumentNullException, empêchant ainsi efficacement les références nulles inattendues.

Affectation composée à coalescence nulle (??=)

Gerald aborde ensuite l'opérateur d'affectation composé de coalescence nulle (??=), qui offre un moyen encore plus rationnel d'attribuer des valeurs par défaut. Au lieu d'écrire :

if (person.Name == null)
{
    person.Name = "Gerald";
}

if (person.Name == null)
{
    person.Name = "Gerald";
}

If person.Name Is Nothing Then
    person.Name = "Gerald"
End If

If person.Name Is Nothing Then
    person.Name = "Gerald"
End If

Il simplifie cela avec :

person.Name ??= "Gerald";

person.Name ??= "Gerald";

person.Name = If(person.Name, "Gerald")

person.Name = If(person.Name, "Gerald")

Gerald explique que ??= n'attribue la valeur spécifiée que si l'opérande de gauche est nul. Si person.Name a déjà une valeur, elle reste inchangée. Cet opérateur est particulièrement utile pour initialiser les champs ou s'assurer que les variables ne restent jamais nulles.

Combinaison avec l'opérateur conditionnel Null

Dans la dernière section, Gerald démontre comment l'opérateur de coalescence null peut être combiné avec l'opérateur conditionnel null ( ?.). L'opérateur conditionnel null permet un accès sécurisé aux propriétés sans provoquer un NullReferenceException. Il donne un exemple :

var length = person?.Name?.Length ?? 0;

var length = person?.Name?.Length ?? 0;

Dim length As Integer = If(person?.Name?.Length, 0)

Dim length As Integer = If(person?.Name?.Length, 0)

Gérald explique que cela garantit que si person ou Name est null, le résultat par défaut est 0 au lieu de lancer une exception. Cette combinaison est utile lorsque l'on travaille avec des types de référence nullables ou des hiérarchies d'objets complexes.

Conclusion

Tout au long de la vidéo, Gerald Versluis explique efficacement la puissance de l'opérateur de coalescence nulle ( ??) et de l'affectation composée de coalescence nulle (??=). Il démontre comment ces opérateurs peuvent remplacer les vérifications traditionnelles de nullité, rendant le code plus concis et plus lisible. En tirant parti de ces fonctionnalités, les développeurs peuvent écrire des applications C# plus propres et plus efficaces.

Si vous souhaitez voir ces concepts en action, consultez la vidéo complète de Gerald Versluis sur "Comprendre l'opérateur de coalescence nulle du C# ( ??? et ??=)"