Wie überprüft man, ob ein Objekt Nullable ist?

Gibt es zwei Typen der null - Nullable<T> - und Referenz-Typ.

Jon hat mich korrigiert, es ist schwer zu bekommen, geben Sie, wenn boxed, aber man kann mit generics:
- also etwa wie unten. Dies ist eigentlich die Prüfung Typ T, aber mit der obj parameter rein für den generischen Typ-Inferenz (um es einfach zu nennen) - es würde funktionieren fast identisch, ohne die obj param, obwohl.

static bool IsNullable<T>(T obj)
{
    if (obj == null) return true; //obvious
    Type type = typeof(T);
    if (!type.IsValueType) return true; //ref-type
    if (Nullable.GetUnderlyingType(type) != null) return true; //Nullable<T>
    return false; //value-type
}

Aber das funktioniert nicht so gut, wenn Sie bereits Originalverpackung den Wert einer Objektvariable.

InformationsquelleAutor der Antwort Marc Gravell

Die Frage: "Wie um zu überprüfen, ob ein Typ auf null gesetzt werden?" ist eigentlich "Wie zu überprüfen, ob ein Typ ist Nullable<>?", das kann verallgemeinert werden, um "zu prüfen, Wie wenn ein Typ einen konstruierten Typ von generischer Typ?", so, dass es nicht nur Antworten auf die Frage "Ist Nullable<int> eine Nullable<>?", aber auch "Ist List<int> eine List<>?".

Meisten der zur Verfügung gestellten Lösung verwenden Sie die Nullable.GetUnderlyingType() Methode, die offensichtlich nur mit dem Fall der Nullable<>. Ich konnte nicht sehen die Allgemeinen reflektierende Lösung, die die Arbeit mit jedem generischen Typ, also beschloss ich, fügen Sie es hier für die Nachwelt, auch wenn diese Frage schon beantwortet wurde vor langer Zeit.

Um zu überprüfen, ob eine Art eine form von Nullable<> mit der spiegelung, müssen Sie zuerst konvertieren Sie Ihre konstruierten generischen Typ, zum Beispiel Nullable<int> in die generische Typdefinition Nullable<>. Sie können tun, dass durch die GetGenericTypeDefinition() Methode der Type Klasse. Sie können dann vergleichen die daraus resultierende Art zu Nullable<>:

Type typeToTest = typeof(Nullable<int>);
bool isNullable = typeToTest.GetGenericTypeDefinition() == typeof(Nullable<>);
//isNullable == true

Das gleiche kann angewendet werden, um beliebige generische Typ:

Type typeToTest = typeof(List<int>);
bool isList = typeToTest.GetGenericTypeDefinition() == typeof(List<>);
//isList == true

Mehrere Arten mag das gleiche, aber eine unterschiedliche Anzahl von Typ-Argumente bedeutet, es ist eine ganz andere Art.

Type typeToTest = typeof(Action<DateTime, float>);
bool isAction1 = typeToTest.GetGenericTypeDefinition() == typeof(Action<>);
bool isAction2 = typeToTest.GetGenericTypeDefinition() == typeof(Action<,>);
bool isAction3 = typeToTest.GetGenericTypeDefinition() == typeof(Action<,,>);
//isAction1 == false
//isAction2 == true
//isAction3 == false

Seit Type Objekt instanziiert werden einmal pro Typ, Sie können überprüfen für Referenz-Gleichheit zwischen Ihnen. Also, wenn Sie wollen, um zu überprüfen, ob zwei Objekte den gleichen generischen Typ-definition können Sie schreiben:

var listOfInts = new List<int>();
var listOfStrings = new List<string>();

bool areSameGenericType =
    listOfInts.GetType().GetGenericTypeDefinition() ==
    listOfStrings.GetType().GetGenericTypeDefinition();
//areSameGenericType == true

Wenn Sie möchten, um zu überprüfen, ob ein Objekt auf null gesetzt werden, anstatt eine Typedann können Sie mit der oben genannten Technik gemeinsam mit Marc Gravell ' s Lösung für die Erstellung von eine ziemlich einfache Methode:

static bool IsNullable<T>(T obj)
{
    if (!typeof(T).IsGenericType)
        return false;

    return typeof(T).GetGenericTypeDefinition() == typeof(Nullable<>);
}

InformationsquelleAutor der Antwort Allon Guralnek

Dies funktioniert für mich und scheint einfach:

static bool IsNullable<T>(T obj)
{
    return default(T) == null;
}

InformationsquelleAutor der Antwort Erik

Gibt es hier zwei Probleme: 1) testen, um zu sehen, ob ein Typ auf null gesetzt werden; und 2) testen, um zu sehen, ob ein Objekt stellt eine nullable-Typ.

Für Heft 1 (Prüfung Typ), hier ist eine Lösung, die ich verwendet habe, in meinem eigenen Systemen: TypeIsNullable-check-Lösung

Für Heft 2 (Test Objekt), Dean Kreide die Lösung von oben funktioniert für value-Typen, aber es funktioniert nicht für Referenz-Typen, da die Verwendung des <T> überlastung immer false zurück. Da Referenz-Typen sind von Natur aus null-Werte zulässt, Test eines Referenz-Typ sollte immer true zurück. Bitte beachten Sie den Hinweis [Über die "Zulässigkeit"] unten für eine Erläuterung dieser Semantik. So, hier ist meine Modifikation von Dean ' s Ansatz:

    public static bool IsObjectNullable<T>(T obj)
    {
        //If the parameter-Type is a reference type, or if the parameter is null, then the object is always nullable
        if (!typeof(T).IsValueType || obj == null)
            return true;

        //Since the object passed is a ValueType, and it is not null, it cannot be a nullable object
        return false; 
    }

    public static bool IsObjectNullable<T>(T? obj) where T : struct
    {
        //Always return true, since the object-type passed is guaranteed by the compiler to always be nullable
        return true;
    }

Und hier ist meine Modifikation der client-test-code für die obige Lösung:

    int a = 123;
    int? b = null;
    object c = new object();
    object d = null;
    int? e = 456;
    var f = (int?)789;
    string g = "something";

    bool isnullable = IsObjectNullable(a); //false 
    isnullable = IsObjectNullable(b); //true 
    isnullable = IsObjectNullable(c); //true 
    isnullable = IsObjectNullable(d); //true 
    isnullable = IsObjectNullable(e); //true 
    isnullable = IsObjectNullable(f); //true 
    isnullable = IsObjectNullable(g); //true

Der Grund, warum ich geändert habe Dean ' s Ansatz in IsObjectNullable<T>(T t) ist, dass seine ursprünglichen Ansatz immer falsch zurückgegeben, die für ein Referenz-Typ. Da eine Methode wie IsObjectNullable sollte in der Lage sein zu handhaben Referenz-Typ-Werte und da alle Referenz-Typen sind von Natur aus null-Werte zulässt, dann, wenn ein Referenz-Typ oder null übergeben wird, sollte die Methode immer true zurück.

Den beiden oben genannten Methoden ersetzt werden könnten, die mit der single-Methode und erreichen die gleiche Ausgabe:

    public static bool IsObjectNullable<T>(T obj)
    {
        Type argType = typeof(T);
        if (!argType.IsValueType || obj == null)
            return true;
        return argType.IsGenericType && argType.GetGenericTypeDefinition() == typeof(Nullable<>);
    }

Jedoch, das problem mit dieser letzten single-method-Ansatz ist, dass die Leistung leidet, wenn ein Nullable<T> - parameter verwendet wird. Es braucht viel mehr Prozessor-Zeit zur Ausführung der letzten Zeile dieser Methode, als es dem compiler zu erlauben, wählen Sie die zweite Methode überlast angezeigt, wenn zuvor eine Nullable<T>-Typ-parameter wird in der IsObjectNullable nennen. Daher die optimale Lösung ist die Verwendung der zwei-Methode hier dargestellt.

NACHTEIL: Diese Methode funktioniert nur zuverlässig, wenn mit dem ursprünglichen Objekt-Referenz oder eine genaue Kopie, wie gezeigt in den Beispielen. Allerdings, wenn Sie eine null-Objekt ist boxed zu einem anderen Typ (z.B. Objekt, etc.) statt der noch in seiner ursprünglichen Nullable<> form, funktioniert diese Methode nicht zuverlässig. Wenn der code ruft diese Methode ist nicht mit dem original, ohne Verpackung-Objekt-Referenz oder eine genaue Kopie, es kann nicht zuverlässig bestimmen, das Objekt ist null-Zulässigkeit der Verwendung dieser Methode.

In den meisten coding-Szenarien, um zu bestimmen, die null-Zulässigkeit muss man stattdessen verlassen Sie sich auf die Prüfung der ursprünglichen Objekttyp nicht seine Referenz (z.B., muss der code zum Zugriff auf das Objekt die ursprünglichen Typ zu bestimmen, die null-Zulässigkeit). In diesen häufigeren Fällen, IsTypeNullable (siehe link) ist eine zuverlässige Methode zur Bestimmung der Zulässigkeit.

P. S. - Über die "Zulässigkeit"

Sollte ich wiederholen eine Aussage über die null-Zulässigkeit, die ich in einem separaten post, das gilt unmittelbar für richtig Auseinandersetzung mit diesem Thema. Das ist, glaube ich, dass der Fokus der Diskussion sollte nicht hier sein, wie Sie überprüfen, um zu sehen, ob ein Objekt einer generischen Nullable-Typ, sondern eher, ob man einen Wert zuweisen, der von null auf ein Objekt von Typ. In anderen Worten, ich denke, wir sollten ermitteln, ob ein Objekt geben Sie ist null-Werte zulässt, nicht, ob Sie null-Werte zulässt. Der Unterschied liegt in der Semantik, nämlich die praktischen Gründe für die Bestimmung der null-Zulässigkeit, die in der Regel alles, die was zählt.

In einem system, das Objekte mit Typen möglicherweise unbekannt, bis der run-time (web-services, remote-Aufrufe, Datenbanken, RSS-feeds, etc.), eine häufige Anforderung ist es, zu bestimmen, ob eine null werden kann, die dem Objekt zugewiesen wird oder ob ein Objekt enthalten kann, eine null. Die Durchführung solcher Operationen auf nicht-nullable-Typen werden wahrscheinlich Fehler produzieren, in der Regel Ausnahmen, die sind sehr teuer, sowohl in Bezug auf Leistung und Codierung-Anforderungen. Nehmen die hoch-bevorzugte Ansatz der proaktiven Vermeidung solcher Probleme ist es notwendig, um festzustellen, ob ein Objekt eines beliebigen Typs ist in der Lage mit einer null; D. H., ob es generell so ist 'nullable'.

In einer sehr praktischen und typischen Sinn, null-Zulässigkeit .NETTO bedeutet nicht notwendigerweise, dass ein Objekt-Typ ist eine form der null. In vielen Fällen in der Tat, Objekte sind Referenztypen, kann einen null-Wert enthalten, und somit sind alle null-Werte zulässt; keiner von Ihnen haben eine Nullable-Typ. Daher ist für praktische Zwecke in den meisten Szenarien, testen getan werden sollte, für das Allgemeine Konzept der null-Zulässigkeit, gegen die von der Implementierung abhängige Konzept der null. Also wir sollten nicht aufgehängt werden, durch die Fokussierung ausschließlich auf die .NET Nullable-Typ, sondern integrieren unser Verständnis Ihrer Anforderungen und das Verhalten im Prozess der Fokussierung auf das Allgemeine, das praktische Konzept der null-Zulässigkeit.

InformationsquelleAutor der Antwort Mark Jones

Die einfachste Lösung kam ich mit ist die Implementierung der Microsoft-Lösung (Gewusst wie: Identifizieren einer Nullable-Typ (C# - Programmierhandbuch)) als eine Erweiterung-Methode:

public static bool IsNullable(this Type type)
{
    return type.IsGenericType && type.GetGenericTypeDefinition() != typeof(Nullable<>);
}

Diese kann dann aufgerufen werden, etwa so:

bool isNullable = typeof(int).IsNullable();

Das scheint auch eine logische Weg, um Zugang IsNullable() weil es passt, mit all den anderen IsXxxx() Methoden der Type Klasse.

InformationsquelleAutor der Antwort sclarke81

Dieser version:

• Zwischenspeichern der Ergebnisse ist schneller,
• erfordert keine unnötigen Variablen, wie die Methode(T obj)
• NICHT KOMPLIZIERT :),
• nur statische generische Klasse, die eine Zeit berechnete Felder

:

public static class IsNullable<T>
{
    private static readonly Type type = typeof(T);
    private static readonly bool is_nullable = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
    public static bool Result { get { return is_nullable; } }
}

bool is_nullable = IsNullable<int?>.Result;

InformationsquelleAutor der Antwort ipavlu

einen einfachen Weg, dies zu tun:

    public static bool IsNullable(this Type type)
    {
        if (type.IsValueType) return Activator.CreateInstance(type) == null;

        return true;
    }

diese sind meine unit-tests und alle bestanden

    IsNullable_String_ShouldReturn_True
    IsNullable_Boolean_ShouldReturn_False
    IsNullable_Enum_ShouldReturn_Fasle
    IsNullable_Nullable_ShouldReturn_True
    IsNullable_Class_ShouldReturn_True
    IsNullable_Decimal_ShouldReturn_False
    IsNullable_Byte_ShouldReturn_False
    IsNullable_KeyValuePair_ShouldReturn_False

eigentlichen unit-tests

    [TestMethod]
    public void IsNullable_String_ShouldReturn_True()
    {
        var typ = typeof(string);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Boolean_ShouldReturn_False()
    {
        var typ = typeof(bool);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Enum_ShouldReturn_Fasle()
    {
        var typ = typeof(System.GenericUriParserOptions);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Nullable_ShouldReturn_True()
    {
        var typ = typeof(Nullable<bool>);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Class_ShouldReturn_True()
    {
        var typ = typeof(TestPerson);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Decimal_ShouldReturn_False()
    {
        var typ = typeof(decimal);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Byte_ShouldReturn_False()
    {
        var typ = typeof(byte);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_KeyValuePair_ShouldReturn_False()
    {
        var typ = typeof(KeyValuePair<string, string>);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

InformationsquelleAutor der Antwort VJPPaz