如何检查对象是否可为空？

如何检查给定对象是否可为空，换句话说，如何实现以下方法...

bool IsNullableValueType(object o)
{
    ...
}

编辑：我正在寻找可为空的值类型。我没有想到ref类型。

//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现在引用值等于的bool（System.Boolean）类型的对象true。我真正想要的是一个类型的对象Nullable<bool>

因此，现在作为一项解决方案，我决定检查o是否可为空，并围绕obj创建可为空的包装器。

有两种类型的可为空值- Nullable<T>和引用类型。

乔恩（Jon）已纠正我的意见，即如果用方框将其键入很难得到，但是您可以使用泛型：-那么下面呢。这实际上是在测试type T，但是仅将obj参数用于泛型类型推断（以便于调用）- obj尽管没有参数，它的工作原理几乎相同。

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
}

但是，如果您已将该值装箱到对象变量中，则此方法将无法很好地工作。

Microsoft文档：https : //docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/nullable-types/how-to-identify-a-nullable-type

使用方法重载有一个非常简单的解决方案

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

摘抄：

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

然后

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

问题“如何检查类型是否可为空？” 实际上是“如何检查是否一个类型是Nullable<>？”，这可以概括为“如何检查，如果一个类型是一些通用型的构造类型？”，所以，它不仅回答了这个问题：“是Nullable<int>一个Nullable<>？”而且还“是List<int>一个List<>？”。

提供的大多数解决方案都使用该Nullable.GetUnderlyingType()方法，该方法显然仅适用于的情况Nullable<>。我没有看到适用于任何泛型类型的通用反射解决方案，因此，我决定在此添加它，以供后代使用，即使这个问题早已得到解答。

要检查某个类型是否是Nullable<>使用反射的某种形式，您首先必须将构造的泛型类型转换为例如Nullable<int>泛型类型定义Nullable<>。您可以通过使用类的GetGenericTypeDefinition()方法来实现Type。然后，您可以将结果类型与进行比较Nullable<>：

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

这可以应用于任何泛型类型：

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

几种类型看似相同，但是类型参数的数量不同意味着它是完全不同的类型。

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

由于Type每种类型实例化对象一次，因此您可以检查它们之间的引用相等性。因此，如果要检查两个对象是否具有相同的通用类型定义，则可以编写：

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

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

如果您想检查对象是否可为空，而不是Type，则可以将上述技术与马克·格雷夫（Marc Gravell）的解决方案结合使用来创建一个相当简单的方法：

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

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

这对我有用，看起来很简单：

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

对于值类型：

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

好吧，您可以使用：

return !(o is ValueType);

...但是对象本身是不能为null的，否则不能为空- 类型是可以的。您打算如何使用它？

我能找出的最简单方法是：

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

这里有两个问题：1）测试类型是否可为空；2）测试对象是否代表可为null的Type。

对于问题1（测试类型），这是我在自己的系统中使用的解决方案：TypeIsNullable-check解决方案

对于问题2（测试对象），上述Dean Chalk的解决方案适用于值类型，但不适用于引用类型，因为使用<T>重载始终返回false。由于引用类型本质上可以为空，因此测试引用类型应始终返回true。请参阅下面的注释[关于“可空性”]，以获取这些语义的解释。因此，这是我对Dean方法的修改：

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

这是我对上述解决方案的客户端测试代码的修改：

    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

我之所以在IsObjectNullable <T>（T t）中修改Dean的方法的原因是，对于引用类型，他的原始方法始终返回false。由于像IsObjectNullable这样的方法应该能够处理引用类型的值，并且由于所有引用类型本质上都可以为空，因此，如果传递了引用类型或null，则该方法应始终返回true。

可以将以下两种方法替换为以上两种方法，并获得相同的输出：

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

但是，最后一种单方法的问题是，当使用Nullable <T>参数时，性能会受到影响。与在IsObjectNullable调用中使用Nullable <T>类型的参数时，允许编译器选择前面显示的第二种方法重载相比，执行此单个方法的最后一行要花更多的处理器时间。因此，最佳解决方案是使用此处说明的两种方法。

CAVEAT：仅当使用原始对象引用或精确副本进行调用时，此方法才能可靠地工作，如示例所示。但是，如果将可为空的对象装箱到其他类型（例如对象等），而不是保留其原始的Nullable <>形式，则此方法将无法可靠地工作。如果调用此方法的代码未使用原始的，未装箱的对象引用或精确副本，则无法使用此方法可靠地确定对象的可空性。

在大多数编码方案中，要确定可为空性，必须改为依靠测试原始对象的类型而不是其引用（例如，代码必须有权访问对象的原始Type来确定可为空性）。在这些更常见的情况下，IsTypeNullable（请参阅链接）是确定可为空性的可靠方法。

PS-关于“可空性”

我应该在另一篇文章中重复有关可空性的声明，该声明直接适用于正确解决此主题。也就是说，我相信这里的讨论重点不应是如何检查对象是否为通用Nullable类型，而是应该是否可以为该类型的对象分配null值。换句话说，我认为我们应该确定对象类型是否可为空，而不是它是否可为空。区别在于语义上，即确定可为空性的实际原因，通常这很重要。

在使用对象的类型直到运行时可能未知的系统（Web服务，远程调用，数据库，提要等）中，一个共同的要求是确定是否可以将null分配给该对象，或者该对象是否可能包含空值。对非空类型执行此类操作可能会产生错误，通常是异常，这在性能和编码要求方面都非常昂贵。为了采取主动避免此类问题的首选方法，有必要确定任意类型的对象是否能够包含null。即，它通常是否为“可为空”。

从非常实际和典型的意义上讲，.NET术语中的可为空性不一定表示对象的类型是可为空的形式。实际上，在许多情况下，对象具有引用类型，可以包含空值，因此都可以为空。这些都没有Nullable类型。因此，出于实用目的，在大多数情况下，应该针对可空性的一般概念进行测试，而不是依赖于实现的概念。因此，我们不应该只专注于.NET Nullable类型，而应该将我们对它的要求和行为的理解纳入到专注于一般的，实用的nullability概念的过程中。

我想到的最简单的解决方案是将Microsoft的解决方案（如何：识别可空类型（C＃编程指南））作为扩展方法来实现：

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

然后可以这样称呼它：

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

这似乎也是一种合乎逻辑的访问方式，IsNullable()因为它适合于该类的所有其他IsXxxx()方法Type。

装箱可为空的类型（Nullable<int>例如int？）时要小心：

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

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

它成为真正的引用类型，因此您将失去它可以为空的事实。

也许没有话题，但仍然有一些有趣的信息。我发现有很多人可以Nullable.GetUnderlyingType() != null用来识别类型是否可为空。这显然是可行的，但是Microsoft建议采取以下措施type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)（请参阅http://msdn.microsoft.com/zh-cn/library/ms366789.aspx）。

我从性能的角度看待这个问题。下面的测试结论（尝试一百万次）是，当类型为可为空时，Microsoft选项将提供最佳性能。

Nullable.GetUnderlyingType（）： 1335毫秒（慢3倍）

GetGenericTypeDefinition（）== typeof（可空<>）： 500ms

我知道我们在谈论的时间很少，但是每个人都喜欢调整毫秒数：-)！因此，如果您是老板希望减少几毫秒的时间，那么这就是您的救星...

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

这个版本：

• 缓存结果更快，
• 不需要不必要的变量，例如Method（T obj）
• 不复杂:)，
• 只是静态的通用类，它具有一次计算字段

：

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;

这就是我想出的，因为其他所有事情似乎都失败了-至少在PLC上-具有> = C＃6的可移植类库 / .NET Core

解决方案：将静态方法扩展为任何类型T，Nullable<T>并使用以下事实：与基础类型匹配的静态扩展方法将被调用，并且优先于通用T扩展方法。

对于T：

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

和为 Nullable<T>

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

type.IsGenericType在我当前的.NET运行时集上，无法使用Reflection和...。MSDN文档也没有帮助。

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

部分原因是由于.NET Core中的反射API进行了相当大的更改。

我认为使用Microsoft建议的测试针对的测试IsGenericType是好的，但是在的代码中GetUnderlyingType，Microsoft使用了另一项测试来确保您未传递泛型类型定义Nullable<>：

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

一种简单的方法：

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

        return true;
    }

这些是我的单元测试，都通过了

    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

实际单元测试

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