C#: Alternative zu GenericType == null

Brauche ich, um zu überprüfen Sie ein generisches Objekt für null oder default(T). Aber ich habe ein problem... Momentan habe ich es gemacht wie hier:

if (typeof(T).IsValueType)
{
  if(default(T).Equals(thing))
    //Do something
  else
    //Do something else
}
else
{
  if(thing == null)
    //Do something
  else
    //Do something else
}

Aber dann habe ich am Ende hin, mich zu wiederholen... was ich nicht mag. Das problem ist Folgendes:

thing == null;

Hier ReSharper warnt über Mögliche Vergleiche von Wert-Typ mit 'null'.

thing == default(T);

Hier bekomme ich compiler Fehler: Cannot apply-operator '==' auf Operanden vom Typ 'T' und 'T'.

thing.Equals(null|default(T));

thing können offensichtlich null sein (das ist, warum ich habe zu prüfen!), so wird NullReferenceException.

null|default(T).Equals(thing);

null und default(T) ist sehr oft null...

Ist es eine saubere Art und Weise, dies zu tun??

InformationsquelleAutor Svish | 2009-02-19
  1. 26

    Wenn Boxen ist nicht ein Problem, Sie könnten einfach verwenden:

    object.Equals(value, default(T))
    • Ich wusste nicht, dass das möglich war.
    • und das wird funktionieren, wenn beide null sind?
    • Es funktioniert. Die Prüfung ist nicht schwer, Svish...
    • Ich bin überrascht, wie Komplex die anderen Antworten sind für diese.
    • Wie schwer die Prüfung ist, hängt davon ab, wo Sie sind. Danke Jeff, wird wahrscheinlich am Ende mit dieser Methode =)
    • Sehen Jasons Antwort für einen one-liner, der keine Boxen.

    InformationsquelleAutor Jeff Yates
  2. 54

    Den richtigen Weg, dies zu tun ist:

    return EqualityComparer<T>.Default.Equals(value, default(T))

    Keine Boxen. Man könnte auch definieren, eine Erweiterung Methode wie diese:

    public static void bool IsDefault<T>(this T value)
{
    return EqualityComparer<T>.Default.Equals(value, default(T));
}

    .. und rufen Sie es wie folgt:

    return entry.IsDefault();

    Obwohl, ich persönlich don ' T care für die Erweiterung Methoden auf T (z.B. dieses Objekt IsNull ()), da es erschwert die Lesbarkeit manchmal.

    • Oh, nice one 🙂
    • Dies ist ein kleines, geniales Stück code. Vielen Dank für das teilen.
    • Während ich mag diese Antwort, ich kann nicht angemessen in allen Fällen. Eine häufige Ort, wo diese überprüfung geschieht, ist die überprüfung von Argumenten an eine Methode übergeben. Wenn die Absicht, dies zu überprüfen wird eine exception werfen, wenn eine Methode erhält ein null-argument, das wird nicht funktionieren, für den Fall, wo jemand absichtlich übergibt eine 0. In diesem Fall denke ich, das zurücksetzen auf if (value == null) funktioniert wie erwartet für alle Fälle und ist viel besser lesbar (und daher sauber).
    • 0 ist der default-Wert eines integer ohne Verpackung, aber ist nicht der Standard, der eine null-int. Bitte geben Sie ein Beispiel Signatur der Methode, die highlights Ihrer Anliegen.
    InformationsquelleAutor Jason
  3. 8

    Wenn ich brauche, um zu testen, ob der Wert NULL ist, ich benutze die unten aufgeführte Methode. Ich in der Regel verwenden Sie diese beim Aufruf von Methoden jeder Art, aber nicht null, wie der Cache.

    public static bool IsNull<T>(this T value)
{
    var type = typeof(T);

    return (type.IsClass || Nullable.GetUnderlyingType(type) != null) 
        && EqualityComparer<T>.Default.Equals(value, default(T));

}
    • Type.IsClass false für Schnittstellen. !Type.IsValueType ist wahrscheinlich das, was Sie wollen. (Ich glaube, Sie brauchen noch die nullable-check.)
    InformationsquelleAutor Damien McGivern
  4. 2

    Etwas von Boxen wird den job zu erledigen just fine.

        static bool IsNullOrDefault<T>(T value)
    {
        return ((object)default(T)) == null ?
            ((object)value) == null :
            default(T).Equals(value);
    }
    • Ist das nicht genau sagen-Objekt.Equals(default(T), Wert)?
    InformationsquelleAutor Anton Gogolev
  5. 2

    Beste Sache, die ich denken kann, im moment ist:

    return value == null || value.Equals(default(T));

    Edit:

    Offenbar gibt es eine statische object.Equals Methode, die ich nicht bewusst war:

    return object.Equals(value, default(T));

    Dies ist besser.

    • aber was dann geschehen wird, wenn der Wert einen Wert geben?
    • (value == null) würde false zurückgeben. (Wert ist.Equals(default(T)) zu überprüfen wäre gegen den Standard.
    • Dies verhindert nur Boxen, wenn es eine Equals-Implementierung auf die Art, die sich eher als die Standard -, die nimmt ein Objekt. In Anbetracht dieser, ich glaube, dass Objekt.Equals(value, default(T)) ist einfacher zu Lesen.
    • Ich bin damit einverstanden. Wie ich schon sagte, Objekt.Equals() ist eine Methode, die ich nicht bewusst war.
    • Die Equals-Implementierung muss Objekt überschreiben.Gleich um genannt zu werden. So dass diese nie vermeidet Boxen.
    • Vermeiden Sie Boxen durch die Implementierung von IEquatable.
    • Aber natürlich muss man die Anfrage für Sie, dass, bevor Rückgriff auf Objekt.Entspricht.

    InformationsquelleAutor configurator
  6. 1

    Können Sie vermeiden-Boxen zusammen mit der Feststellung, dass die null-Zulässigkeit einer type kann bestimmt werden, statisch.

    Hier ist was Sie tun können:

    1. Deklarieren private static read-only variable namens isDefault Typ Predicate<T> in die generische Klasse
    2. Fügen Sie einen statischen Initialisierer, um die generische Klasse, wo Sie T-Zulässigkeit, und legen Sie isDefault entweder v==null oder default(T).Equals(v) je nach Ergebnis
    3. Verwenden isDefault(x) statt x==null im rest des Codes

    Hier ist ein Beispiel:

    public class Example<T> {

    private static readonly Predicate<T> isDefault;

    static Example() {
        //Nullability check is a bit ugly, but we do it once per T,
        //so what the heck...
        if (typeof(T).IsValueType &&
           (!typeof(T).IsGenericType
        ||  typeof(T).GetGenericTypeDefinition() != typeof(Nullable<>)
        )) {
            //This is safe because T is not null
            isDefault = val => default(T).Equals(val);
        } else {
            //T is not a value type, so its default is null
            isDefault = val => val == null;
        }
    }

    public bool Check(T value) {
        //Now our null-checking is both good-looking and efficient
        return isDefault(value);
    }

}
    • Was ist, wenn die Methode ist generisch, aber die Klasse nicht?
    InformationsquelleAutor
  7. 0

    Tests:

    public class DefaultOrNullChecker<T>  {
    public bool Check(object x) {
        return object.ReferenceEquals(x, null) || x.Equals(default(T));
    }
}
[TestFixture]
public class Tests {
    [Test]  public void when_T_is_reference_type() { 
        Assert.IsFalse(new DefaultOrNullChecker<Exception>().Check(new Exception()));}
    [Test] public void when_T_is_value_type() { 
        Assert.IsFalse(new DefaultOrNullChecker<int>().Check(123)); }
    [Test] public void when_T_is_null() {
        Assert.IsTrue(new DefaultOrNullChecker<Exception>().Check(null));}
    [Test] public void when_T_is_default_value() { 
        Assert.IsTrue(new DefaultOrNullChecker<int>().Check(0)); }
}
    • Das spielt überhaupt keine Rolle, da der Vergleich erfolgt auf T-constraint-vs T-Einschränkung, d.h. Objekt == object. Das ist das gleiche wie Objekt.ReferenceEquals.
    InformationsquelleAutor George Mauer
  8. -1

    Was ist Los mit diesem?

    if (thing == default(T)) { }

    Wenn es einen Wert geben Sie dann den JIT wird einfach entfernen Sie die Aussage insgesamt.

    • Es wird nicht kompiliert. Cannot apply operator '==' to operands of type 'T' and 'T'
    InformationsquelleAutor Andrew Hare
Schreibe einen Kommentar