Markiere Parameter als NULL in C# /. NET NULL?

Question

Gibt es ein einfaches Attribut oder einen Datenvertrag, den ich einem Funktionsparameter zuweisen kann, der verhindert, dass null in C# /. NET übergeben wird? Idealerweise würde dies auch zur Kompilierzeit prüfen, um sicherzustellen, dass das Literal null nirgendwo dafür verwendet wird und zur Laufzeit ArgumentNullException geworfen wird.

Zur Zeit schreibe ich so etwas wie ...

if (null == arg) 
    throw new ArgumentNullException("arg"); 

... für jedes Argument, das ich null nicht erwarten sein.

Auf die gleiche Note, gibt es ein gegenüber Nullable<> wobei folgende scheitern würde:

NonNullable<string> s = null; // throw some kind of exception 

Answer 1

Es zur Compile-Zeit verfügbar ist nichts, leider.

Ich habe ein bisschen von hacky solution, die ich in meinem Blog vor kurzem veröffentlicht, die eine neue Struktur und Konvertierungen verwendet.

In .NET 4.0 mit den Code Contracts Sachen wird das Leben viel schöner. Es wäre immer noch ziemlich nett, die aktuelle Sprachsyntax zu haben und die Nicht-NULL-Fähigkeit zu unterstützen, aber die Code-Verträge werden viel helfen.

Ich habe auch eine Erweiterungsmethode in MiscUtil namens ThrowIfNull, die es ein bisschen einfacher macht.

Ein letzter Punkt - ein Grund für die Verwendung von "if (null == arg)" anstelle von "if (arg == null)"? Ich finde das Letztere leichter zu lesen, und das Problem, das der frühere in C löst, trifft nicht auf C# zu.

Answer 2

Überprüfen Sie die Validierer in der Enterprise-Bibliothek. Sie können so etwas wie tun:

private MyType _someVariable = TenantType.None; 
[NotNullValidator(MessageTemplate = "Some Variable can not be empty")] 
public MyType SomeVariable { 
    get { 
     return _someVariable; 
    } 
    set { 
     _someVariable = value; 
    } 
} 

dann in Ihrem Code, wenn Sie es überprüfen möchten:

Microsoft.Practices.EnterpriseLibrary.Validation.Validator myValidator = ValidationFactory.CreateValidator<MyClass>(); 

ValidationResults vrInfo = InternalValidator.Validate(myObject); 

Answer 3

public void foo(int? id, string name) 
{ 
    if (id == null) 
    { 
     throw new ArgumentNullException("id"); 
    } 
    if (name == null) 
    { 
     throw new ArgumentNullException("name"); 
    } 

    this.foo = id.Value; 
    this.fooName = name; 
} 

Dort gehen Sie, sonst nur andere Anweisung definieren.

Answer 4

nicht die schönste, aber:

public static bool ContainsNullParameters(object[] methodParams) 
{ 
    return (from o in methodParams where o == null).Count() > 0; 
} 

Sie könnten mehr kreativ in der ContainsNullParameters Methode erhalten:

public static bool ContainsNullParameters(Dictionary<string, object> methodParams, out ArgumentNullException containsNullParameters) 
     { 
      var nullParams = from o in methodParams 
          where o.Value == null 
          select o; 

      bool paramsNull = nullParams.Count() > 0; 


      if (paramsNull) 
      { 
       StringBuilder sb = new StringBuilder(); 
       foreach (var param in nullParams) 
        sb.Append(param.Key + " is null. "); 

       containsNullParameters = new ArgumentNullException(sb.ToString()); 
      } 
      else 
       containsNullParameters = null; 

      return paramsNull; 
     } 

natürlich Sie einen Abfangjäger oder Reflexion nutzen könnten, aber diese sind leicht zu folgen/Verwenden Sie mit wenig Overhead

Answer 5

Ok, diese Antwort ist ein bisschen spät, aber hier ist, wie ich es lösen:

public static string Default(this string x) 
{ 
    return x ?? ""; 
} 

Verwenden Sie diese Erweiterungsmethode, dann können Sie null und leere Zeichenfolge als die gleiche Sache behandeln.

z.

Nicht ideal Ich weiß, wie Sie daran denken müssen, Standard überall anrufen, aber es ist eine Lösung.

Answer 6

Ich weiß, dass dies eine sehr alte Frage, aber dieses fehlte hier:

Wenn Sie ReSharper verwenden Sie die Annotated Framework verwenden.

Answer 7

Ich weiß, ich bin unglaublich spät zu dieser Frage, aber ich denke, die Antwort wird relevant werden, wie die letzte große Iteration von C# kommt näher zu veröffentlichen, dann veröffentlicht. In C# 8.0 wird eine größere Änderung auftreten, C# wird annehmen, alle Typen werden als nicht null betrachtet.

Nach Mads Torgersen:

Das Problem ist, dass null Referenzen so nützlich sind. In C# sind sie der Standardwert jedes Referenztyps. Was wäre sonst der Standardwert ? Welchen anderen Wert würde eine Variable haben, bis Sie entscheiden können, was sie sonst noch zuweisen soll? Welchen anderen Wert könnten wir ein frisch zugewiesenes Array von Referenzen mit überlagern, bis Sie um ausfüllen es ausfüllen?

Manchmal ist null auch ein vernünftiger Wert an und für sich. Manchmal möchten Sie die Tatsache darstellen, dass, sagen wir, ein Feld keinen Wert hat. Es ist in Ordnung, "nichts" für einen Parameter zu übergeben. Die Betonung liegt jedoch manchmal auf . Und hierin liegt ein weiterer Teil des Problems: Sprachen wie C# lassen Sie nicht ausdrücken, ob eine Null hier eine gute Idee ist oder nicht.

So ist die Auflösung von Mads umrissen ist:

1. Wir glauben, dass es häufiger ist eine Referenz zu wollen, nicht null zu sein. Nullable Referenztypen wäre die seltenere Art (obwohl wir keine guten Daten haben, um uns durch zu sagen, wie viel), so sind sie diejenigen, die eine neue Anmerkung benötigen sollten.

2. Die Sprache hat bereits eine Vorstellung von - und einer Syntax für - Nullwerttypen. Die Analogie zwischen den beiden würde die Sprache konzeptionell einfacher und sprachlich einfacher machen.

3. Es scheint richtig, dass Sie sich oder Ihre Verbraucher nicht mit umständlichen Nullwerten belasten sollten, es sei denn Sie haben aktiv entschieden, dass Sie sie wollen. Nullen, nicht die Abwesenheit von ihnen, sollte die Sache sein, die Sie explizit in aktivieren müssen.

Ein Beispiel für die gewünschte Funktion:

public class Person 
{ 
    public string Name { get; set; } // Not Null 
    public string? Address { get; set; } // May be Null 
} 

Die Vorschau für Visual Studio 2017 zur Verfügung steht, 15.5.4+ Vorschau.