C# Academy · Leçon

Se prémunir contre les valeurs nulles

Validation et schémas.

Se prémunir contre les valeurs nulles est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Pourquoi se prémunir contre les valeurs nulles ?

Une méthode qui reçoit une valeur null inattendue provoque souvent plus tard une NullReferenceException déroutante, profondément enfouie dans la pile d'appels.

Se protéger consiste à vérifier les arguments dès le départ et à échouer clairement, afin que l'erreur désigne directement sa véritable cause.

Vérification classique de la nullité

La protection la plus simple consiste à effectuer une vérification explicite qui déclenche une ArgumentNullException lorsqu'un argument requis est nul.

Cette vérification valide l'entrée à la limite de votre méthode, avant que tout traitement ne commence.

void Save(string path)
{
    if (path == null)
        throw new System.ArgumentNullException(nameof(path));
    System.Console.WriteLine(path);
}

Utiliser le nom du paramètre

Transmettez nameof(path) plutôt qu'une chaîne écrite en dur. L'exception indique alors le nom exact du paramètre et reste correcte si vous renommez celui-ci.

Le débogage est ainsi bien plus facile lorsque l'exception est enregistrée dans les journaux.

void Greet(string user)
{
    if (user is null)
        throw new System.ArgumentNullException(nameof(user));
    System.Console.WriteLine("Hi " + user);
}

Assistant ThrowIfNull

Le C# moderne propose ArgumentNullException.ThrowIfNull(arg). Cette instruction vérifie la nullité et déclenche automatiquement une exception avec le nom correct du paramètre.

Cette forme est concise et constitue le style de protection recommandé dans le code .NET actuel.

void Process(object data)
{
    System.ArgumentNullException.ThrowIfNull(data);
    System.Console.WriteLine("Processing");
}

Une protection exécutable

Ce programme montre une protection qui intercepte un argument nul et le signale proprement au lieu de provoquer un plantage ultérieur.

Exécutez-le pour voir le message d'exception qui nomme le mauvais paramètre.

using System;

class Program
{
    static void Print(string text)
    {
        ArgumentNullException.ThrowIfNull(text);
        Console.WriteLine(text);
    }

    static void Main()
    {
        try { Print(null); }
        catch (ArgumentNullException ex) { Console.WriteLine(ex.ParamName); }
    }
}

Se protéger avec ?? et une exception

Vous pouvez combiner affectation et protection en utilisant ?? avec throw. Cela valide et stocke la valeur sur une seule ligne.

Il s'agit d'un modèle courant dans les constructeurs lors de l'affectation d'un champ.

class Service
{
    private readonly string _name;
    public Service(string name)
        => _name = name ?? throw new System.ArgumentNullException(nameof(name));
}

Vide ou nul

Pour les chaînes, une valeur nulle et une valeur vide correspondent à deux problèmes différents. Utilisez string.IsNullOrEmpty ou string.IsNullOrWhiteSpace pour détecter les deux à la fois.

Une ArgumentException (et non une ArgumentNullException) convient à une valeur vide mais non nulle.

void SetName(string name)
{
    if (string.IsNullOrWhiteSpace(name))
        throw new System.ArgumentException("Name required", nameof(name));
}

Se protéger avec des motifs

Les motifs is null et is not null sont clairs à lire et ne peuvent pas être trompés par des opérateurs d'égalité surchargés.

Préférez is null à == null lorsqu'un type est susceptible de redéfinir ==.

object value = null;
if (value is null)
    System.Console.WriteLine("It is null");
if (value is not null)
    System.Console.WriteLine("Has value");

Utiliser une valeur par défaut plutôt que lever une exception

Toute valeur nulle n'est pas forcément une erreur. Parfois, une valeur par défaut raisonnable vaut mieux qu'une exception.

Utilisez ?? lorsque la nullité est acceptable et ne déclenchez une exception que lorsque la valeur est réellement requise.

string BuildPath(string folder)
{
    folder ??= "/tmp";
    return folder + "/file.txt";
}

Les types référence pouvant être nuls sont utiles

Lorsque les types référence pouvant être nuls sont activés, le compilateur vous avertit lorsque vous risquez de déréférencer une valeur qui peut être nulle, ce qui permet de détecter les erreurs avant l'exécution.

Déclarer string (non nul) plutôt que string? (pouvant être nul) documente votre intention et guide l'analyseur.

#nullable enable
string required = "ok";
string? optional = null;
System.Console.WriteLine(optional?.Length ?? 0);

Se protéger, puis utiliser en toute sécurité

Après avoir effectué une protection au début d'une méthode, le reste du corps peut utiliser la valeur sans vérifications de nullité répétées.

Ce programme effectue une protection, puis utilise l'argument en toute confiance.

using System;

class Program
{
    static int Length(string s)
    {
        ArgumentNullException.ThrowIfNull(s);
        return s.Length;
    }

    static void Main()
    {
        Console.WriteLine(Length("hello"));
    }
}

Vérification rapide

Vérifiez votre compréhension de la protection contre les valeurs nulles.

Récapitulatif

Protégez les arguments requis au début d'une méthode. Utilisez ArgumentNullException.ThrowIfNull ou ?? throw avec nameof pour obtenir des erreurs claires.

Utilisez string.IsNullOrWhiteSpace pour les chaînes vides, les motifs is null pour effectuer des vérifications sûres, et ?? lorsqu'une valeur par défaut est acceptable plutôt que d'échouer.

Questions Fréquemment Posées

La leçon « Se prémunir contre les valeurs nulles » est-elle gratuite ?

Oui — le texte complet de « Se prémunir contre les valeurs nulles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Se prémunir contre les valeurs nulles » ?

Validation et schémas. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Se prémunir contre les valeurs nulles » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C# Academy