C# Null safety (Sécurité contre les valeurs Null dans C#)

Tip

Cet article fait partie de la section Notions de base pour les développeurs qui connaissent déjà au moins un langage de programmation et apprennent C#. Si vous débutez avec la programmation, commencez par commencer par les didacticiels De prise en main .

En provenance de Java ou C++ ? C# fournit une sécurité null au moment de la compilation via des types de référence nullables. L'objectif est similaire aux annotations @NonNull de Java, mais appliquées par le compilateur. C# dispose également d'opérateurs dédiés tels que ?. et ??, qui rendent les expressions sécurisées contre les valeurs nulles plus concises.

null représente l’absence d’une valeur. Lorsque vous essayez d’accéder à un membre sur une null référence, en appelant une méthode ou en lisant une propriété, l'environnement d'exécution lève un NullReferenceException:

// Accessing a member on null throws NullReferenceException at runtime:
// string? name = null;
// int length = name.Length; // throws NullReferenceException

// Check before you dereference:
string? name = null;
if (name is not null)
{
    Console.WriteLine($"Name has {name.Length} characters.");
}
else
{
    Console.WriteLine("Name has no value.");
}
// Output: Name has no value.

C# vous donne trois outils complémentaires pour écrire du code null-safe :

• Types de valeurs nullables : laissez un type valeur tel que int ou bool également contenir null
• Types de référence nullables : laissez le compilateur suivre si une référence peut être null
• Opérateurs Null : accès sécurisé contre les null et logique de remplacement facilement et de manière concise

Types de valeur pouvant être nulle

Les types valeur tels que int, doubleet bool ne peuvent pas contenir null par défaut. Ajoutez ? au nom du type pour créer un type valeur nullable qui contient soit une valeur, soit null :

int? score = null;
Console.WriteLine(score.HasValue);               // False

score = 95;
Console.WriteLine(score.HasValue);               // True
Console.WriteLine(score.GetValueOrDefault());    // 95

int? missing = null;
Console.WriteLine(missing.GetValueOrDefault(-1)); // -1

Les types de valeurs nullables sont utiles lorsqu’un type valeur sous-jacent doit représenter « aucune donnée ». Les scénarios courants incluent des colonnes de base de données qui peuvent être absentes, des paramètres de configuration facultatifs et des lectures de capteur qui ne sont pas encore capturées.

Consultez les types de valeur nullable pour obtenir une couverture complète de la déclaration, de la vérification et de la conversion.

Types références Nullables

Les types de référence, tels que string, les tableaux et les instances de classe, peuvent contenir null pendant l'exécution. Les types de référence nullables sont une fonctionnalité du compilateur qui rend l’intention Null explicite et intercepte les erreurs au moment de la compilation.

À l’aide de l’annotation ? , vous déclarez votre intention :

• string? — cette référence peut être null; le compilateur avertit si vous la déréférez sans vérifier d’abord
• string — cette référence ne doit pas être null; le compilateur avertit si vous l’affectez null à celui-ci

// string?  means this reference might be null
// string   means this reference should not be null
string? nullableName = null;
string  nonNullName  = "Alice";

// ?. safely accesses a member when the reference might be null
string display = nullableName?.ToUpper() ?? "(no name)";
Console.WriteLine(display);         // (no name)

display = nonNullName.ToUpper();    // safe: nonNullName is never null
Console.WriteLine(display);         // ALICE

Tous les projets .NET créés avec les modèles SDK modernes activent par défaut les types de référence nullables. Pour obtenir des conseils complets sur l’activation et l’annotation, consultez les types de référence Nullable.

Opérateurs nuls

C# inclut plusieurs opérateurs qui vous permettent d’écrire du code null-safe sans gardes -null manuels ifpartout :

Opérateur	Name	Purpose
?.	Accès au membre conditionnel Null	Accéder à un membre uniquement lorsque l’objet n’est pas null
?[]	Accès à l’indexeur conditionnel Null	Accéder à un élément uniquement lorsque la collection n’a pas la valeur Null
??	Fusion de Null	Retourner une valeur de secours lorsque l’expression est null
??=	Attribution de fusion Null	Affecter uniquement lorsque la variable est null
is null / is not null	Motif nul	Test null préféré

string? city = GetCity();

// ?. — access a member only when non-null
int? len = city?.Length;

// ?? — substitute a default when null
string display = city ?? "unknown";

// is null — preferred null test
if (city is null)
{
    Console.WriteLine("No city provided.");
}
else
{
    Console.WriteLine($"{display} ({len} chars)");
}
// Output: No city provided.

Pour obtenir des exemples détaillés de chaque opérateur, consultez opérateurs Null.

Les types de valeurs nullables et les types de référence nullables ont des objectifs différents

Les types valeur nullable et les types de référence nullables ne constituent pas des alternatives. Ils résolvent différents problèmes :

• Utilisez T? pour un type valeur qui doit représenter « aucune valeur ». Par exemple, utilisez int? une colonne de base de données facultative ou DateTime? pour un événement qui n’est pas encore planifié.
• Utilisez string? et d’autres annotations de référence nullables pour documenter qu’une référence peut être null, de sorte que le compilateur peut vous avertir avant qu’un NullReferenceException événement se produise au moment de l’exécution.

Ensemble, ces fonctionnalités et les opérateurs Null vous donnent un ensemble complet d’outils pour écrire du code C# null-safe.