Was wird bevorzugt: Nullable<T>.HasValue oder Nullable<T> != null?

Der compiler ersetzt null Vergleiche mit einem Aufruf HasValue, so gibt es keinen wirklichen Unterschied. Nur tun, je mehr lesbar/macht mehr Sinn für Sie und Ihre Kollegen.

InformationsquelleAutor Rex M

Habe ich einige der Forschung auf dieser durch die Verwendung verschiedener Methoden, um Werte zuzuweisen, um eine null-int. Hier ist, was passiert, wenn ich nicht verschiedene Dinge. Sollten klären, was Los ist.
Beachten Sie: Nullable<something> oder die Kurzform something? ist eine Struktur, für die der compiler scheint zu tun, eine Menge Arbeit, um uns mit null, als ob es eine Klasse.

Wie Sie unten sehen werden, SomeNullable == null und SomeNullable.HasValue immer wieder ein erwartet true oder false. Obwohl nicht gezeigt, unten SomeNullable == 3 gilt auch (vorausgesetzt, SomeNullable ist ein int?).

Während SomeNullable.Value bringt uns zu einem Laufzeitfehler, wenn wir zugewiesen null zu SomeNullable. Dies ist in der Tat der einzige Fall, wo nullables könnte uns dazu führen, ein problem, Dank einer Kombination von überladen von Operatoren, überladen object.Equals(obj) Methode, und der compiler-Optimierung und monkey business.

Hier ist eine Beschreibung von einigen code, den ich lief, und das, was Ausgabe, die es produziert Etiketten:

int? val = null;
lbl_Val.Text = val.ToString(); //Produced an empty string.
lbl_ValVal.Text = val.Value.ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValEqNull.Text = (val == null).ToString(); //Produced "True" (without the quotes)
lbl_ValNEqNull.Text = (val != null).ToString(); //Produced "False"
lbl_ValHasVal.Text = val.HasValue.ToString(); //Produced "False"
lbl_NValHasVal.Text = (!(val.HasValue)).ToString(); //Produced "True"
lbl_ValValEqNull.Text = (val.Value == null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValValNEqNull.Text = (val.Value != null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")

Ok, probieren wir die nächste Initialisierung Methode:

int? val = new int?();
lbl_Val.Text = val.ToString(); //Produced an empty string.
lbl_ValVal.Text = val.Value.ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValEqNull.Text = (val == null).ToString(); //Produced "True" (without the quotes)
lbl_ValNEqNull.Text = (val != null).ToString(); //Produced "False"
lbl_ValHasVal.Text = val.HasValue.ToString(); //Produced "False"
lbl_NValHasVal.Text = (!(val.HasValue)).ToString(); //Produced "True"
lbl_ValValEqNull.Text = (val.Value == null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValValNEqNull.Text = (val.Value != null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")

Alle die gleichen wie vorher. Beachten Sie, dass die Initialisierung mit int? val = new int?(null); mit null an den Konstruktor übergeben, hätte erzeugt einen COMPILE time error, da die nullable-Objekt der WERT null ist NICHT zulässig. Es ist nur der wrapper-Objekt selbst, die können gleich null.

Ebenfalls, wir würden eine compile-Zeit-Fehler-aus:

int? val = new int?();
val.Value = null;

nicht zu erwähnen, dass val.Value ist ein nur-lese-Eigenschaft sowieso, so können wir nicht einmal so etwas wie:

val.Value = 3;

aber wieder, polymorphe überlastet implizite konvertierungsoperatoren lassen Sie uns tun:

val = 3;

Brauchen keine sorgen zu machen polysomthing whatchamacallits obwohl, so lange, wie es richtig funktioniert? 🙂

InformationsquelleAutor Perrin Larson

Wenn Sie die linq und möchten, dass Ihr code kurz, ich empfehlen immer die Verwendung !=null

Ist, und deshalb:

Lassen Sie sich vorstellen, wir haben einige Klasse Foo mit einem nullable-Doppel - variable SomeDouble

public class Foo
{
    public double? SomeDouble;
    //some other properties
}   

Wenn irgendwo in unserem code, wir wollen alle Foo mit einem nicht-null-SomeDouble Werte aus einer Sammlung von Foo (vorausgesetzt, einige foos in der Sammlung kann null sein), wir am Ende mit mindestens drei Art und Weise zu schreiben, unsere Funktion (wenn wir C# 6) :

public IEnumerable<Foo> GetNonNullFoosWithSomeDoubleValues(IEnumerable<Foo> foos)
{
     return foos.Where(foo => foo?.SomeDouble != null);
     return foos.Where(foo=>foo?.SomeDouble.HasValue); //compile time error
     return foos.Where(foo=>foo?.SomeDouble.HasValue == true); 
     return foos.Where(foo=>foo != null && foo.SomeDouble.HasValue); //if we don't use C#6
}

Und in dieser Art von situation, die ich empfehlen, gehen immer für die kürzere

InformationsquelleAutor yan yankelevich