Wie überprüfe ich, ob ein Objekt nullwertfähig ist?

Wie überprüfe ich, ob ein bestimmtes Objekt nullbar ist? Mit anderen Worten, wie implementiere ich die folgende Methode ...

bool IsNullableValueType(object o)
{
    ...
}

EDIT: Ich suche nach nullbaren Werttypen. Ich hatte keine Ref-Typen im Sinn.

//Note: This is just a sample. The code has been simplified 
//to fit in a post.

public class BoolContainer
{
    bool? myBool = true;
}

var bc = new BoolContainer();

const BindingFlags bindingFlags = BindingFlags.Public
                        | BindingFlags.NonPublic
                        | BindingFlags.Instance
                        ;


object obj;
object o = (object)bc;

foreach (var fieldInfo in o.GetType().GetFields(bindingFlags))
{
    obj = (object)fieldInfo.GetValue(o);
}

obj bezieht sich jetzt auf ein Objekt vom Typ bool( System.Boolean) mit dem Wert gleich true. Was ich wirklich wollte, war ein Objekt vom TypNullable<bool>

Um dies zu umgehen, habe ich mich entschlossen, zu überprüfen, ob o nullbar ist, und einen nullbaren Wrapper um obj zu erstellen.

Es gibt zwei Arten von Nullwerten - Nullable<T>und Referenztypen.

Jon hat mich korrigiert, dass es schwierig ist, einen Typ zu bekommen, wenn er verpackt ist, aber Sie können mit Generika: - Wie wäre es unten? Dies ist eigentlich ein Testtyp T, aber die Verwendung des objParameters dient lediglich der generischen Typinferenz (um das Aufrufen zu vereinfachen) - ohne den objParameter würde er jedoch fast identisch funktionieren.

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
}

Dies funktioniert jedoch nicht so gut, wenn Sie den Wert bereits in eine Objektvariable eingefügt haben.

Microsoft-Dokumentation: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/nullable-types/how-to-identify-a-nullable-type

Es gibt eine sehr einfache Lösung mit Methodenüberladungen

http://deanchalk.com/is-it-nullable/

Auszug:

public static class ValueTypeHelper
{
    public static bool IsNullable<T>(T t) { return false; }
    public static bool IsNullable<T>(T? t) where T : struct { return true; }
}

dann

static void Main(string[] args)
{
    int a = 123;
    int? b = null;
    object c = new object();
    object d = null;
    int? e = 456;
    var f = (int?)789;
    bool result1 = ValueTypeHelper.IsNullable(a); // false
    bool result2 = ValueTypeHelper.IsNullable(b); // true
    bool result3 = ValueTypeHelper.IsNullable(c); // false
    bool result4 = ValueTypeHelper.IsNullable(d); // false
    bool result5 = ValueTypeHelper.IsNullable(e); // true
    bool result6 = ValueTypeHelper.IsNullable(f); // true

Die Frage "Wie kann überprüft werden, ob ein Typ nullwertfähig ist?" ist eigentlich "Wie prüfe Nullable<>ich , ob ein Typ ist ?", was verallgemeinert werden kann auf "Wie prüfe ich, ob ein Typ ein konstruierter Typ eines generischen Typs ist?", so dass nicht nur die Frage "Ist Nullable<int>ein Nullable<>?" beantwortet wird. aber auch "Ist List<int>ein List<>?".

Die meisten der bereitgestellten Lösungen verwenden die Nullable.GetUnderlyingType()Methode, die offensichtlich nur mit dem Fall von funktioniert Nullable<>. Ich habe die allgemeine reflektierende Lösung, die mit jedem generischen Typ funktioniert, nicht gesehen, deshalb habe ich beschlossen, sie hier für die Nachwelt hinzuzufügen, obwohl diese Frage bereits vor langer Zeit beantwortet wurde.

Um zu überprüfen, ob ein Typ eine Form der Nullable<>Reflektion ist, müssen Sie zuerst Ihren konstruierten generischen Typ Nullable<int>in die generische Typdefinition konvertieren Nullable<>. Sie können dies mit der GetGenericTypeDefinition()Methode der TypeKlasse tun . Sie können den resultierenden Typ dann vergleichen mit Nullable<>:

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

Das gleiche kann auf jeden generischen Typ angewendet werden:

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

Mehrere Typen mögen gleich erscheinen, aber eine unterschiedliche Anzahl von Typargumenten bedeutet, dass es sich um einen völlig anderen Typ handelt.

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

Da TypeObjekte einmal pro Typ instanziiert werden, können Sie die Referenzgleichheit zwischen ihnen überprüfen. Wenn Sie also überprüfen möchten, ob zwei Objekte dieselbe generische Typdefinition haben, können Sie Folgendes schreiben:

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

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

Wenn Sie überprüfen möchten, ob ein Objekt nullbar ist und nicht a Type, können Sie die obige Technik zusammen mit der Lösung von Marc Gravell verwenden, um eine recht einfache Methode zu erstellen:

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

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

Das funktioniert bei mir und scheint einfach:

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

Für Werttypen:

static bool IsNullableValueType<T>(T obj)
{
    return default(T) == null && typeof(T).BaseType != null && "ValueType".Equals(typeof(T).BaseType.Name);
}

Nun, Sie könnten verwenden:

return !(o is ValueType);

... aber ein Objekt selbst ist nicht nullbar oder anders - ein Typ ist. Wie wollten Sie das nutzen?

Der einfachste Weg, den ich herausfinden kann, ist:

public bool IsNullable(object obj)
{
    Type t = obj.GetType();
    return t.IsGenericType 
        && t.GetGenericTypeDefinition() == typeof(Nullable<>);
}

Hier gibt es zwei Probleme: 1) Testen, ob ein Typ nullwertfähig ist; und 2) Testen, um zu sehen, ob ein Objekt einen nullbaren Typ darstellt.

Für Problem 1 (Testen eines Typs) ist hier eine Lösung, die ich in meinen eigenen Systemen verwendet habe: TypeIsNullable-Check-Lösung

In Problem 2 (Testen eines Objekts) funktioniert die obige Lösung von Dean Chalk für Werttypen, jedoch nicht für Referenztypen, da die Verwendung der <T> -Überladung immer false zurückgibt. Da Referenztypen von Natur aus nullwertfähig sind, sollte das Testen eines Referenztyps immer true zurückgeben. Eine Erläuterung dieser Semantik finden Sie im Hinweis [Über "Nullbarkeit"] unten. Hier ist meine Modifikation von Deans 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 Änderung am Client-Testcode 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 Deans Ansatz in IsObjectNullable <T> (T t) geändert habe, ist, dass sein ursprünglicher Ansatz für einen Referenztyp immer false zurückgegeben hat. Da eine Methode wie IsObjectNullable in der Lage sein sollte, Referenztypwerte zu verarbeiten, und alle Referenztypen von Natur aus nullwertfähig sind, sollte die Methode immer true zurückgeben, wenn entweder ein Referenztyp oder eine Null übergeben wird.

Die beiden oben genannten Methoden könnten durch die folgende Einzelmethode ersetzt werden und dieselbe Ausgabe erzielen:

    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<>);
    }

Das Problem bei diesem letzten Ansatz mit nur einer Methode besteht jedoch darin, dass die Leistung leidet, wenn ein Nullable <T> -Parameter verwendet wird. Das Ausführen der letzten Zeile dieser einzelnen Methode benötigt viel mehr Prozessorzeit als das Auswählen der zweiten Methodenüberladung, die zuvor angezeigt wurde, wenn im IsObjectNullable-Aufruf ein Parameter vom Typ Nullable <T> verwendet wird. Daher besteht die optimale Lösung darin, den hier dargestellten Zwei-Methoden-Ansatz zu verwenden.

CAVEAT: Diese Methode funktioniert nur dann zuverlässig, wenn sie unter Verwendung der ursprünglichen Objektreferenz oder einer exakten Kopie aufgerufen wird, wie in den Beispielen gezeigt. Wenn ein nullbares Objekt jedoch einem anderen Typ (z. B. einem Objekt usw.) zugeordnet ist, anstatt in seiner ursprünglichen nullbaren <> Form zu bleiben, funktioniert diese Methode nicht zuverlässig. Wenn der Code, der diese Methode aufruft, nicht die ursprüngliche Objektreferenz ohne Box oder eine exakte Kopie verwendet, kann er die Nullfähigkeit des Objekts mit dieser Methode nicht zuverlässig bestimmen.

In den meisten Codierungsszenarien muss man sich zur Bestimmung der Nullbarkeit stattdessen darauf verlassen, den Typ des ursprünglichen Objekts und nicht dessen Referenz zu testen (z. B. muss der Code Zugriff auf den ursprünglichen Typ des Objekts haben, um die Nullfähigkeit zu bestimmen). In diesen häufigeren Fällen ist IsTypeNullable (siehe Link) eine zuverlässige Methode zur Bestimmung der Nullfähigkeit.

PS - Über "Nullability"

Ich sollte eine Aussage über die Nichtigkeit, die ich in einem separaten Beitrag gemacht habe, wiederholen, die direkt für die richtige Behandlung dieses Themas gilt. Das heißt, ich glaube, der Fokus der Diskussion hier sollte nicht darauf liegen, zu überprüfen, ob ein Objekt ein generischer Nullable-Typ ist, sondern ob man einem Objekt seines Typs den Wert Null zuweisen kann. Mit anderen Worten, ich denke, wir sollten bestimmen, ob ein Objekttyp nullbar ist, nicht, ob er nullbar ist. Der Unterschied liegt in der Semantik, nämlich den praktischen Gründen für die Bestimmung der Nullfähigkeit, was normalerweise alles ist, was zählt.

In einem System, das Objekte mit möglicherweise bis zur Laufzeit unbekannten Typen verwendet (Webdienste, Fernaufrufe, Datenbanken, Feeds usw.), besteht eine häufige Anforderung darin, zu bestimmen, ob dem Objekt eine Null zugewiesen werden kann oder ob das Objekt möglicherweise enthält eine Null. Das Ausführen solcher Operationen mit nicht nullbaren Typen führt wahrscheinlich zu Fehlern, normalerweise Ausnahmen, die sowohl hinsichtlich der Leistung als auch der Codierungsanforderungen sehr teuer sind. Um den äußerst bevorzugten Ansatz zu verfolgen, solche Probleme proaktiv zu vermeiden, muss bestimmt werden, ob ein Objekt eines beliebigen Typs eine Null enthalten kann; dh, ob es im Allgemeinen "nullbar" ist.

In einem sehr praktischen und typischen Sinne bedeutet die Nullbarkeit in .NET-Begriffen keineswegs unbedingt, dass der Typ eines Objekts eine Form von Nullable ist. In vielen Fällen haben Objekte tatsächlich Referenztypen, können einen Nullwert enthalten und sind daher alle nullwertfähig. Keiner von diesen hat einen Nullable-Typ. Aus praktischen Gründen sollten daher in den meisten Szenarien Tests für das allgemeine Konzept der Nullbarkeit im Vergleich zum implementierungsabhängigen Konzept der Nullbarkeit durchgeführt werden. Wir sollten uns also nicht nur auf den .NET Nullable-Typ konzentrieren, sondern unser Verständnis seiner Anforderungen und seines Verhaltens in den Prozess der Fokussierung auf das allgemeine, praktische Konzept der Nullbarkeit einbeziehen.

Die einfachste Lösung, die ich gefunden habe, ist die Implementierung der Microsoft-Lösung ( Gewusst wie: Identifizieren eines nullbaren Typs (C # -Programmierhandbuch) ) als Erweiterungsmethode:

public static bool IsNullable(this Type type)
{
    return Nullable.GetUnderlyingType(type) != null;
}

Dies kann dann so genannt werden:

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

Dies scheint auch eine logische Art des Zugriffs zu sein, IsNullable()da es zu allen anderen IsXxxx()Methoden der TypeKlasse passt .

Seien Sie vorsichtig, wenn Sie einen nullbaren Typ ( Nullable<int>oder beispielsweise int?) Boxen :

int? nullValue = null;
object boxedNullValue = (object)nullValue;
Debug.Assert(boxedNullValue == null);

int? value = 10;
object boxedValue = (object)value;
Debug.Assert( boxedValue.GetType() == typeof(int))

Es wird zu einem echten Referenztyp, sodass Sie die Tatsache verlieren, dass es nullbar war.

Vielleicht ein bisschen abseits des Themas, aber immer noch einige interessante Informationen. Ich finde viele Leute, die Nullable.GetUnderlyingType() != nullsich identifizieren, wenn ein Typ nullbar ist. Dies funktioniert natürlich, aber Microsoft empfiehlt Folgendes type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)(siehe http://msdn.microsoft.com/en-us/library/ms366789.aspx ).

Ich habe das von einer Performance-Seite aus gesehen. Die Schlussfolgerung des folgenden Tests (eine Million Versuche) lautet, dass die Microsoft-Option die beste Leistung liefert, wenn ein Typ nullwertfähig ist.

Nullable.GetUnderlyingType (): 1335 ms (dreimal langsamer)

GetGenericTypeDefinition () == typeof (Nullable <>): 500 ms

Ich weiß, dass wir über eine kleine Menge Zeit sprechen, aber jeder liebt es, die Millisekunden zu optimieren :-)! Wenn Ihr Chef möchte, dass Sie einige Millisekunden reduzieren, dann ist dies Ihr Retter ...

/// <summary>Method for testing the performance of several options to determine if a type is     nullable</summary>
[TestMethod]
public void IdentityNullablePerformanceTest()
{
    int attempts = 1000000;

    Type nullableType = typeof(Nullable<int>);

    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();
    for (int attemptIndex = 0; attemptIndex < attempts; attemptIndex++)
    {
        Assert.IsTrue(Nullable.GetUnderlyingType(nullableType) != null, "Expected to be a nullable"); 
    }

    Console.WriteLine("Nullable.GetUnderlyingType(): {0} ms", stopwatch.ElapsedMilliseconds);

    stopwatch.Restart();

    for (int attemptIndex = 0; attemptIndex < attempts; attemptIndex++)
   {
       Assert.IsTrue(nullableType.IsGenericType && nullableType.GetGenericTypeDefinition() == typeof(Nullable<>), "Expected to be a nullable");
   }

   Console.WriteLine("GetGenericTypeDefinition() == typeof(Nullable<>): {0} ms", stopwatch.ElapsedMilliseconds);
   stopwatch.Stop();
}

Diese Version:

• Caching-Ergebnisse sind schneller,
• erfordert keine unnötigen Variablen wie Methode (T obj)
• NICHT KOMPLIZIERT :),
• Nur statische generische Klasse, die einmal berechnete Felder hat

::

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;

Folgendes habe ich mir ausgedacht, da alles andere - zumindest auf der SPS - Portable Class Library / .NET Core mit> = C # 6 zu versagen schien

Lösung: Erweitern Sie statische Methoden für jeden Typ Tund Nullable<T>verwenden Sie die Tatsache, dass die statische Erweiterungsmethode, die dem zugrunde liegenden Typ entspricht, aufgerufen wird und Vorrang vor der generischen TErweiterungsmethode hat.

Für T:

public static partial class ObjectExtension
{
    public static bool IsNullable<T>(this T self)
    {
        return false;
    }
}

und für Nullable<T>

public static partial class NullableExtension
{
    public static bool IsNullable<T>(this Nullable<T> self) where T : struct
    {
        return true;
    }
}

Die Verwendung von Reflection und type.IsGenericType... funktionierte bei meinem aktuellen Satz von .NET-Laufzeiten nicht. Die MSDN-Dokumentation hat auch nicht geholfen.

if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)) {…}

Zum Teil, weil die Reflection-API in .NET Core erheblich geändert wurde.

Ich denke, diejenigen, die die von Microsoft vorgeschlagenen Tests verwenden, IsGenericTypesind gut, aber im Code für GetUnderlyingTypeverwendet Microsoft einen zusätzlichen Test, um sicherzustellen, dass Sie die generische Typdefinition nicht bestanden haben Nullable<>:

 public static bool IsNullableType(this Type nullableType) =>
    // instantiated generic type only                
    nullableType.IsGenericType &&
    !nullableType.IsGenericTypeDefinition &&
    Object.ReferenceEquals(nullableType.GetGenericTypeDefinition(), typeof(Nullable<>));

ein einfacher Weg, dies zu tun:

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

        return true;
    }

Dies 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

tatsächliche 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);
    }