Dot.Blog

Depuis longtemps, l'utilisation de null en tant que valeur de retour dans les méthodes C# a été une pratique courante pour indiquer l'absence de résultat. Mais ce n'est plus le cas ...

Par exemple, une méthode GetCustomer(52) qui recherche un client par son identifiant pourrait retourner null si le client n°52 n'existe pas. Bien que cette approche soit simple et directe, elle pose de nombreux problèmes. L'un des principaux inconvénients est l'obligation pour les développeurs de vérifier la nullité de chaque variable obtenue par une méthode susceptible de retourner null. Cela ajoute une complexité et un risque d'erreur considérables dans le code.

Problèmes Causés par les null

Les vérifications de nullité peuvent facilement être oubliées, ce qui entraîne des erreurs d'exécution (NullReferenceException) pouvant être difficiles à diagnostiquer et à corriger. De plus, le code devient encombré de vérifications de nullité répétitives, ce qui le rend plus difficile à lire et à maintenir.

var customer = GetCustomer(52);
 if (customer != null)
 {
     // Traitement du client
 }
 else
 {
     // Gestion de l'absence de client
 }
 ```

Ces vérifications constantes alourdissent le code et augmentent la probabilité d'erreurs humaines.

Enumerable.Empty<T> : Une Stratégie Plus Sécurisée

Une meilleure pratique pour les méthodes qui retournent des collections consiste à utiliser Enumerable.Empty<T> au lieu de null. Cette approche élimine le besoin de vérifications de nullité, rendant le code plus propre et plus sûr.

public IEnumerable<Customer> GetCustomers()
 {
     return someCondition ? new List<Customer> { new Customer() } : Enumerable.Empty<Customer>();
 }
 ```

Avec cette approche, vous pouvez directement itérer sur le résultat sans craindre une exception de référence nulle.

```csharp
 foreach (var customer in GetCustomers())
 {
     // Traitement du client
 }
 ```

Le Comportement par Défaut de C# 8.0 et les Types Nullables

Depuis C# 8.0, une nouvelle fonctionnalité a été introduite : les types de référence non-nullables par défaut. Cela peut surprendre certains développeurs, car la logique derrière cette fonctionnalité peut sembler contre-intuitive. En activant cette fonctionnalité, vous indiquez que les types sont non-nullables par défaut, et vous devez explicitement marquer les types de référence qui peuvent être null en utilisant le type nullable (par exemple, string?). Lorsque vous désactiver cette nouvelle fonctionnalités, vous revenez au système précédent où tout est nullable par défaut. Donc enable/disable fonctionne un peu à l'envers de ce qu'on pourrait croire... Attention donc.

#nullable enable
 public class CustomerService
 {
     public Customer? GetCustomer(int id)
     {
         // Retourne soit un Customer, soit null (présence de ? dans le type de retour)
     }
 }
 ```

Cette fonctionnalité peut être activée ou désactivée globalement :

 #nullable enable // Types de référence non-nullables par défaut
 #nullable disable // Types de référence nullables par défaut
 ```

#nullable enable
 public string GetCustomerName(Customer? customer)
 {
     // Ici, customer peut être null, donc une vérification est nécessaire
     if (customer == null)
     {
         return "Unknown";
     }
     return customer.Name;
 }
 ```