Gestion des types nullable en C#

En C# nous avons plusieurs façon de gérer les objets qui peuvent être null.

Nous allons voir ici plusieurs opérateurs disponibles pour cela.

L'opérateur conditionnel ternaire ? :

En anglais, cet opérateur se nomme ternary conditional operator.

Il renvoie une valeur différente si une condition est vraie ou fausse.

Dans cet exemple nous voulons savoir si un nombre est pair ou non et afficher un message à l'écran.

void Main()
{
  bool EstPair(int x) => (x % 2 == 0);
	
  int a = 1;
  // Lecture de la ligne suivante
  // (condition à valider) ? (valeur si condition vraie) : (valeur si condition fausse)
  // est-ce que c'est pair ? on retourne un message pair : on retourne un message impair
  string res = EstPair(a) ? "pair" : "impair";
  Console.WriteLine($"Le nombre {a} est {res}");

  // Affiche à l'écran:
  // Le nombre 1 est impair

  a = 2;
  res = EstPair(a) ? "pair" : "impair";
  Console.WriteLine($"Le nombre {a} est {res}");
  // Affiche à l'écran:
  // Le nombre 2 est pair
}

L'opérateur de fusion null ??

En anglais, cet opérateur se nomme null-coalescing operator.

Si l'opérande gauche n'est pas null alors l'opérateur renvoie l'opérande de gauche, sinon il évalue l'opérande de droite et retourne le résultat.

void Main()
{
  int? nbEnfants = null;
  // Si nbEnfants est null alors on retourne -1
  // Si nbEnfants n'est pas null on retourne la valeur de nbEnfants
  Console.WriteLine(nbEnfants ?? -1);
  // Affiche -1

  nbEnfants = 1;
  Console.WriteLine(nbEnfants ?? -1);
  // Affiche 1
}

L'opérateur conditionnel null d'accès aux membres ?.

En anglais, cet opérateur se nomme null-conditional member access operator.

Cet opérateur joue le role d'un court-circuit lors d'un accès à un membre d'un objet.

void Main()
{
  Person p = null;
  // La ligne ci-dessous lancerait une NullReferenceException
  // Console.WriteLine(p.Name);

  // Ici, si p est null alors la valeur de retour est null
  Console.WriteLine(p?.Name);
}

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

L'opérateur conditionnel null d'accès aux éléments ?[]

En anglais, cet opérateur se nomme null-conditional element access operator.

Cet opérateur joue le role d'un court-circuit lors d'un accès à un élément d'un tableau.

void Main()
{
  Person[] p = null;
  // La ligne ci-dessous lancerait une NullReferenceException
  // Console.WriteLine(p[0].Name);

  // Ici, si p est null alors la valeur de retour est null
  // si p n'est pas null, mais que p[0] contient null alors la valeur de retour est null
  // sinon on affiche la valeur de la propriété Name
  Console.WriteLine(p?[0]?.Name);
}

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

L'opérateur d'assignation de fusion null ??=

Cet opérateur est apparu avec C# 8, en anglais il se nomme null-coalescing assignment operator.

Son objectif est d'assigner une valeur par défaut si l'opérande de gauche est null.

void Main()
{
  int? a = null;
  Console.WriteLine($"a => {a}");
  // Affiche à l'écran
  // a =>

  // Si a est null alors on lui affecte la valeur 3
  a ??= 3;

  Console.WriteLine($"a => {a}");
  // Affiche à l'écran
  // a => 3

  a ??= 4;
  Console.WriteLine($"a => {a}");
  // Affiche à l'écran
  // a => 3
}