Vérification des paramètres nuls en C# 10 et .NET 6 en 10 minutes ou moins

Présentation de la situation - Vérification des paramètres nuls

Tim commence par créer une simple application console .NET 6 pour montrer comment les vérifications de paramètres nuls sont gérées en C#. Il efface le code passe-partout et déclare une variable de type chaîne nullable :

string? info = null;

string? info = null;

Cet objet nul représente un scénario dans lequel un appel de méthode peut recevoir un argument qui n'a pas été correctement instancié. Tim définit ensuite une méthode simple :

void SayHi(string message)
{
    Console.WriteLine($"Bonjour {message}");
}

void SayHi(string message)
{
    Console.WriteLine($"Bonjour {message}");
}

Il transmet la variable info à la méthode :

SayHi(info);

SayHi(info);

Lorsque le programme s'exécute, le résultat s'affiche simplement :

Bonjour

Aucune exception ne se produit car la concaténation de chaînes accepte une valeur nulle et la traite comme une chaîne vide. Mais, comme le souligne Tim, dans la plupart des méthodes du monde réel, cela peut entraîner des situations sujettes à erreur où une référence nulle conduit à des problèmes en aval ou à une NullReferenceException plus loin dans la pile d'appels.

Pour créer un code robuste, les développeurs doivent valider les arguments et s'assurer que toute méthode attend une entrée valide et non nulle.

Vérification traditionnelle de la nullité avant C# 10

Tim explique qu'avant C# 10, la bonne pratique consistait à vérifier manuellement les paramètres et à lancer une exception ArgumentNullException si nécessaire. Il ajoute qu'à l'intérieur de la méthode SayHi :

if (message is null)
    throw new ArgumentNullException(nameof(message));

if (message is null)
    throw new ArgumentNullException(nameof(message));

Cette vérification garantit que si un argument nul est transmis, le programme lance immédiatement une nouvelle instance de la classe ArgumentNullException.

Lorsque Tim exécute le code, le message d'erreur apparaît clairement :

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

Cette exception non gérée indique que la méthode a reçu un argument non valide. Le nom du paramètre - dans ce cas, "message" - est automatiquement affiché dans la sortie, ce qui aide le développeur à identifier exactement l'argument à l'origine du problème.

Tim précise que cette vérification du manuel fonctionne parfaitement dans le .NET Framework et les versions antérieures du .NET Core. Cependant, elle est verbeuse et répétitive lorsqu'il s'agit de paramètres multiples. Chaque paramètre supplémentaire nécessitant une validation ajoute trois ou quatre lignes de code, encombrant le corps de la méthode.

L'approche simplifiée en C# 10 - ArgumentNullException.ThrowIfNull()

À ce stade, Tim présente la syntaxe moderne de C# 10. Au lieu d'écrire plusieurs lignes pour chaque paramètre, les développeurs peuvent maintenant écrire une seule ligne de vérification de nullité :

ArgumentNullException.ThrowIfNull(message);

ArgumentNullException.ThrowIfNull(message);

Tim explique que cette ligne de conduite effectue en interne la même logique de validation. Si l'argument transmis est null, la méthode lève automatiquement une exception, comme auparavant, mais avec une syntaxe beaucoup plus claire.

Lorsque le programme s'exécute à nouveau, la sortie suivante apparaît :

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

System.ArgumentNullException: Value cannot be null. (Parameter 'message')

Le comportement reste identique, mais la syntaxe est simplifiée. Il n'est pas nécessaire d'instancier manuellement un nouvel objet ArgumentNullException à l'aide d'un constructeur ou de spécifier manuellement le paramètre paramName. Le nom du paramètre de l'appelant est automatiquement déduit par le compilateur.

Tim souligne que cette amélioration permet de gagner du temps et de réduire le risque d'erreur humaine en cas de référence à un nom de paramètre erroné.

Exemple : Paramètres multiples

Tim compare ensuite la méthode traditionnelle à la nouvelle méthode lorsqu'il s'agit de gérer des paramètres multiples.

Avant C# 10, un développeur pourrait écrire :

if (name is null)
    throw new ArgumentNullException(nameof(name));
if (email is null)
    throw new ArgumentNullException(nameof(email));
if (password is null)
    throw new ArgumentNullException(nameof(password));

if (name is null)
    throw new ArgumentNullException(nameof(name));
if (email is null)
    throw new ArgumentNullException(nameof(email));
if (password is null)
    throw new ArgumentNullException(nameof(password));

Grâce à l'amélioration C# 10, les mêmes vérifications peuvent désormais être rédigées de manière plus succincte :

ArgumentNullException.ThrowIfNull(name);
ArgumentNullException.ThrowIfNull(email);
ArgumentNullException.ThrowIfNull(password);

ArgumentNullException.ThrowIfNull(name);
ArgumentNullException.ThrowIfNull(email);
ArgumentNullException.ThrowIfNull(password);

Cette amélioration ne se limite pas à la réduction du nombre de lignes : elle rend vos méthodes plus propres, plus lisibles et plus faciles à maintenir. Tim note que si votre méthode attend trois paramètres, vous n'avez plus besoin que de trois vérifications de nullité, au lieu de douze lignes de code.

Pourquoi c'est important - Un code plus sûr et plus robuste

Tim souligne que si le fait de passer manuellement null à une chaîne de caractères dans une démo n'est peut-être pas réaliste, cela représente des problèmes réels. Les API, les entrées utilisateur, les processus de désérialisation ou les opérations de retour d'objet peuvent produire des objets nuls de manière inattendue.

En ajoutant des contrôles de nullité au début d'une méthode, vous évitez les comportements inattendus et les échecs rapides, c'est-à-dire que le programme lève une exception au début de la pile d'appels avant que le problème ne se propage.

Il mentionne également que cette nouvelle syntaxe vous aide à maintenir des modèles de traitement des erreurs cohérents dans vos méthodes. Elle encourage l'écriture d'un code robuste qui résiste aux entrées non valides et aux objets non explicites.

Détails de l'exception ArgumentNull

Tim souligne que ArgumentNullException fait partie de l'espace de noms System et hérite de la classe ArgumentException. Il est lancé lorsqu'une référence nulle est transmise à une méthode qui ne l'accepte pas comme argument valide.

Elle comprend généralement :

• Le nom du paramètre à l'origine du problème.

• Un message d'erreur clair : "La valeur ne peut pas être nulle"

• La pile d'appels, montrant où l'exception s'est produite.

L'exemple de Tim montre comment .NET 6 continue à suivre ce comportement tout en améliorant la syntaxe.

Il note également brièvement que les développeurs peuvent combiner ces vérifications avec d'autres fonctionnalités telles que l'opérateur de coalescence nulle ( ??) ou les valeurs par défaut pour fournir une logique de repli, par exemple :

message ??= "Default message";

message ??= "Default message";

Cela permet à une méthode d'attribuer une valeur par défaut au lieu de lancer, si on le souhaite.

Importance de la vérification de la valeur nulle dans la gestion des erreurs

Tim rappelle aux développeurs que même si C# prend désormais en charge les types de référence nullables, les vérifications de nullité à l'exécution restent essentielles. Le compilateur ne peut pas détecter tous les problèmes liés aux références nulles, en particulier lorsque les données proviennent de sources externes ou de méthodes sur lesquelles vous n'avez aucun contrôle.

Il insiste sur le fait qu'il est bon de vérifier les arguments et de lancer une exception ArgumentNull le cas échéant, afin de s'assurer que la méthode ne s'exécute que si les données d'entrée sont valides. Cela permet de minimiser les erreurs d'exécution, de simplifier la gestion des erreurs et d'éviter les défaillances silencieuses.

Conclusion et perspectives

En guise de conclusion, Tim note que C# 11 apportera encore plus d'améliorations, mais pour l'instant, ArgumentNullException.ThrowIfNull() est l'une des meilleures petites améliorations pour la gestion des erreurs et la sécurité du code dans .NET 6.

Il encourage les développeurs à essayer cette approche dans leurs propres projets et à voir à quel point leurs méthodes paraissent plus propres. Il termine par une question : "Que pensez-vous de ce changement dans C# 10 ?"

Conclusion

La vidéo de Tim Corey montre clairement que la méthode ArgumentNullException.ThrowIfNull() est une amélioration simple mais puissante de C# 10. Elle réduit le code manuel sujet aux erreurs, garantit la validité des arguments et permet à vos programmes d'échouer rapidement lorsqu'un argument nul est transmis.

En utilisant cette méthode de manière cohérente, les développeurs peuvent créer un code robuste, lisible et facile à maintenir, qui gère proprement les exceptions et évite les bogues subtils liés aux références nulles.

En résumé, chaque fois que votre méthode attend un paramètre valide et que vous souhaitez éviter les arguments nuls, suivez l'exemple de Tim Corey et utilisez :

ArgumentNullException.ThrowIfNull(parameterName);

ArgumentNullException.ThrowIfNull(parameterName);

Il s'agit d'un moyen plus propre, plus sûr et plus moderne de protéger votre code contre les valeurs nulles et les erreurs d'exécution dans .NET 6 et au-delà.