Existe-t-il un moyen d'exiger qu'un argument fourni à une méthode ne soit pas nul?

Question

Existe-t-il une meilleure façon d'exiger qu'un argument ne soit pas nul dans une méthode? Je continue à vérifier si l'un des arguments requis par ma méthode est null, comme indiqué ci-dessous. Mais je me demande s'il y a un meilleur moyen.

public void MyMethod(string a, int b) 
{ 
    if(a==null){throw new ArgumentNullException("a");} 
    if(b==null){throw new ArgumentNullException("b");} 

    //more stuff here 
} 

Answer 1

Rick Brewster (auteur de Paint.NET) blogué sur une API Courant alternatif:

http://blog.getpaint.net/2008/12/06/a-fluent-approach-to-c-parameter-validation/

Answer 2

Il n'y a pas d'autre meilleur moyen. C'est ainsi qu'une tonne de bibliothèques Microsoft gère la situation.

Vous pouvez toujours utiliser une méthode d'extension pour le rendre un peu plus clair.

static IsNullArgument(this Object o, string arg) 
{ 
    if (o == null) 
     throw ArgumentNullException(arg); 
} 

Answer 3

J'aime personnellement CuttingEdge.Conditions. Il est facile à utiliser et rend le texte beaucoup plus lisible.

Answer 4

C'est l'un des rares domaines où je pense que C# est allé en arrière de C++.

En C++, vous pouvez écrire

void foo(Bar& bar) { /*...*/ } 

pour indiquer très clairement à la fois le compilateur et les autres humains qui foo une instance réelle a pris de Bar. Oui, il est possible - avec effort - de passer une référence nulle à foo mais ce n'est pas vraiment légal C++.

Votre seule « solution » (de toutes sortes) en C# est de faire vos class es struct s au lieu, comme les types de valeur dans .NET ne peut pas être null (dans votre exemple, b ne peut jamais être null parce que c'est un System.Int32). L'appel à bar() ne compilera pas:

class A { } 
    struct B { } 

    static void foo(A a) { } 
    static void bar(B b) { } 

    static void Main(string[] args) 
    { 
     foo(null); 
     bar(null); 
    } 

Il semble certainement qu'il aurait été agréable pour C# avoir fait (beaucoup) plus difficile d'avoir null références; F #, par exemple, n'a aucun type Nullable.

Pour quelques commentaires intéressants liés à ce sujet, lisez Null References: The Billion Dollar Mistake (et les commentaires).

---

Edit: A Février 2013 la note de Eric Lippert dit: » ... il se trouve que lorsque C# a d'abord été mis en œuvre il y avait des types de référence toujours nullable, ... il semble plausible que Nullable<T> pourrait avoir Nous pouvions avoir un système de type où Nullable<string> était la seule façon légale de représenter "une chaîne qui peut être null". ... "