Travailler avec null : opérateurs ??, ?., ?, !, default

1. L’opérateur de coalescence null (??)

Tes connaissances sur les types nullable ne seront pas complètes sans savoir écrire des constructions concises et sûres. En C#, t’as deux opérateurs ultra pratiques pour ça : la coalescence null (??) et l’opérateur conditionnel null (?.).

L’opérateur ?? te permet de définir une “valeur par défaut” pour une variable qui peut être null.

Imagine que t’as un nom d’utilisateur qui peut être null. Et si c’est vraiment null, tu veux afficher "Invité". Exemple :

string userName = null;
string displayName = userName != null ? userName : "Invité";

L’opérateur ?? permet d’écrire ça plus court :

string userName = null;
string displayName = userName ?? "Invité";

Comment ça marche :

• Si l’expression à gauche n’est pas null, elle est renvoyée comme résultat.
• Si à gauche c’est null, on prend la valeur de droite.

Encore des exemples :

int? age = null;
int displayAge = age ?? -1; // -1 — valeur par défaut
Console.WriteLine(displayAge); // Affichera -1

string input = null;
string name = input ?? "Invité";
Console.WriteLine($"Salut, {name}!"); // Salut, Invité!

Chaînes d’opérateurs

Tu peux enchaîner les ?? :

string result = str1 ?? str2 ?? "Par défaut";

Si str1 n’est pas null, on l’utilise. Sinon — str2, et si lui aussi est null — alors la chaîne "Par défaut".

2. L’opérateur conditionnel null (?.)

Autre cas fréquent : appeler une méthode ou accéder à une propriété d’un objet seulement si l’objet n’est pas null. Exemple :

User user = null;
string displayName = user != null ? user.Name : null;

L’opérateur ?. permet d’écrire ça plus simplement :

User user = null;
string displayName = user?.Name;

Si l’objet user vaut null, l’expression ne va pas planter, elle va juste renvoyer null.

Exemples :

User user = null;

// Sans ?. — ça plante
// Console.WriteLine(user.Name); // NullReferenceException

Console.WriteLine(user?.Name); // Safe — affiche une chaîne vide ou rien

Console.WriteLine(user?.GetProfileInfo()); // Pareil

User[] users = null;
int? count = users?.Length; // null si users == null

Chaînes d’opérateurs

Tu peux faire des "chaînes" entières :

string domain = company?.Director?.Email?.Split('@')?[1];

Si n’importe quelle partie du chemin est null, l’expression renverra null au lieu de lever une exception.

Combiner avec ??

Les opérateurs ?. et ?? marchent super bien ensemble :

string display = user?.Name ?? "Inconnu";

Si user ou user.Name valent null, ça affichera "Inconnu".

3. C’est quoi ! et à quoi ça sert

Opérateur de suppression d’avertissement sur null

Dans les versions récentes de C# (avec NRT activé), le compilateur te prévient si tu accèdes à une variable qui peut être null. Mais parfois, t’es sûr que tout est sous contrôle. Là, tu utilises l’opérateur de suppression !.

string? possibleNull = GetUserNameMaybeNull();
Console.WriteLine(possibleNull.Length); // Warning : possible null

Console.WriteLine(possibleNull!.Length); // Le compilateur se tait, mais si c’est null — exception

Important : ! ne protège pas des bugs — il dit juste au compilateur "fais-moi confiance". Si la variable est vraiment null, t’auras une NullReferenceException.

Où il ne faut pas l’utiliser

Utilise pas ! à l’aveugle. Le bon style, c’est de le minimiser. Mieux vaut réorganiser ton code pour que null soit impossible ou bien géré.

4. default — comment obtenir la "valeur standard" d’un type

Parfois, tu veux juste "réinitialiser" une variable à son état initial, surtout si t’as pas envie d’écrire à la main 0, false ou null.

Pour ça, y’a le mot-clé default.

int a = default;            // a == 0
bool flag = default;        // flag == false
string s = default;         // s == null
double? d = default;        // d == null

Dans ton mini-app, tu peux par exemple reset le nom ou l’âge :

userName = default; // null
userAge = default;  // null (si userAge est int?)

5. Différences et subtilités : ?, !, default

Même les devs expérimentés s’y perdent parfois quand ils voient ?, ! et default côte à côte. On va clarifier qui fait quoi.

? — tu autorises null

• Pour les types valeurs : int? x — maintenant x peut être null.
• Pour les types référence : string? s — tu indiques explicitement que la variable peut être null (en mode NRT).

! — tu affirmes qu’il n’y aura pas de null

• user!.Name — tu promets au compilateur que user n’est pas null.
• Fonctionne seulement en mode Nullable Reference Types.

default — tu demandes la valeur "par défaut"

• int x = default; — x sera 0
• string s = default; — s sera null

Comparatif :

int?

string?

!

default

6. Erreurs classiques avec ?, ! et default

Erreur n°1 : croire que ! "guérit" le null.
En vrai, ! fait juste taire le compilateur. Si la valeur est quand même null, ton programme va planter avec une NullReferenceException.

Erreur n°2 : oublier de vérifier .HasValue avant d’utiliser .Value.
Surtout pour int?, bool? et autres types nullable. Sans cette vérif, tu risques une InvalidOperationException.

Erreur n°3 : utiliser default là où il faut un "zéro spécial".
Par exemple, 0 ou false peuvent être des valeurs valides, pas des signaux de "vide". Ça peut causer des bugs logiques.

Erreur n°4 : ne pas utiliser ? pour les types référence en mode NRT — ou en abuser.
Certains oublient le ? et le compilateur balance plein d’avertissements. D’autres, au contraire, en mettent partout, même là où null n’arrive jamais. Les deux nuisent à la lisibilité et à la fiabilité du code.

2

Mission

C# SELF, niveau 14, leçon 3

Bloqué

Un exemple simple avec l'opérateur `??`

Un exemple simple avec l'opérateur `??`

Ouvrir

2

Mission

C# SELF, niveau 14, leçon 3

Bloqué

L'opérateur null-conditionnel `?.`

L'opérateur null-conditionnel `?.`

Ouvrir