C# distingue les types qui peuvent être de ceux qui ne peuvent pas l'être. () permettent aux types valeur de contenir null, (une fonctionnalité du compilateur) aident à détecter les bugs liés à null, et (, , ) rendent le travail avec des valeurs potentiellement null clean et sûr — résolvant le problème ubiquitaire de la référence null.
nullint??.??!int x = 5; // a value type — CANNOT be null
int? y = null; // int? = Nullable<int> — CAN be null
if (y.HasValue) { int val = y.Value; } // check + access
int z = y ?? 0; // default if null
Les types valeur ne peuvent normalement pas être null, mais int? (Nullable<int>) le permet — courant pour les données optionnelles/manquantes (par exemple, une colonne de base de données nullable).
#nullable enable // (on by default in modern projects)
string name = null; // ⚠️ warning — string is non-nullable by default now
string? maybe = null; // ✅ string? explicitly allows null
void Use(string? s) {
Console.WriteLine(s.Length); // ⚠️ warning — s might be null (must check first)
}
Avec les types référence nullable activés, le compilateur suit quelles références peuvent être null (string?) par rapport à celles qui ne peuvent pas l'être (string) et avertit quand vous risquez de déréférencer null — détectant les bugs NullReferenceException au moment de la compilation. C'est une fonctionnalité de sécurité majeure du C# moderne.
// ?. null-conditional — short-circuits to null instead of throwing
int? len = user?.Name?.Length; // null if user or Name is null (no exception)
user?.DoSomething(); // only calls if user isn't null
// ?? null-coalescing — provide a default
string name = input ?? "Anonymous";
name ??= "fallback"; // assign if currently null
// ! null-forgiving — assert non-null (suppress the warning; use carefully)
string definitelyNotNull = maybe!; // "I know it's not null" — no runtime check
L'opérateur conditionnel null (?.) accède de manière sûre aux membres de valeurs potentiellement null (en retournant null au lieu de lever une exception), et ?? fournit des valeurs par défaut — ensemble, ils rendent la gestion des valeurs null clean et sûre.
La gestion des valeurs null est l'un des aspects les plus importants de l'écriture d'un C# robuste, car NullReferenceException (« l'erreur d'un milliard de dollars ») est l'une des erreurs d'exécution les plus courantes — et les types nullable et les opérateurs de C# les adressent directement, les rendant essentiels à connaître. Les types valeur nullable (int?) sont pratiquement nécessaires pour représenter les données optionnelles/manquantes (champs de base de données nullable, valeurs optionnelles).
La fonctionnalité types référence nullable (activée par défaut dans les projets .NET modernes) est une amélioration majeure de la sécurité : en faisant en sorte que le compilateur suive et avertisse des possibles déréférençages null, elle détecte toute une classe de bugs liés à null à la compilation plutôt que comme des plantages d'exécution — un bénéfice de fiabilité significatif que vous devriez comprendre et respecter.
Les opérateurs de gestion des valeurs null sont des outils quotidiens qui rendent le travail avec des valeurs potentiellement null clean et sûr : l'opérateur conditionnel null (?.) navigue de manière sûre les chaînes potentiellement null (en retournant null au lieu de lever une exception), ??/??= fournissent des valeurs par défaut de manière concise, et ! affirme la non-nullité (à utiliser avec prudence).
Comprendre les types valeur nullable, la fonctionnalité de sécurité des types référence nullable, et les opérateurs de gestion des valeurs null (?., ??, !) est important pour écrire un C# null-safe et robuste qui évite la NullReferenceException ubiquitaire — une préoccupation fréquente et pratiquement critique.
Comme les bugs liés à null sont si courants et C# fournit des outils puissants (en particulier la vérification null au moment de la compilation) pour les prévenir, maîtriser les types nullable et les opérateurs null est une connaissance fondamentale, essentielle à connaître, pour écrire un C# moderne fiable.