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

Question

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

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现在指的是type bool(System.Boolean)的对象,其值等于true.我真正想要的是一个类型的对象Nullable<bool>

所以现在作为一个解决方法我决定检查o是否可以为空并在obj周围创建一个可空的包装器.

Answer 1

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

乔恩已经纠正我,如果盒装的话很难获得类型,但是你可以使用泛型: - 所以下面怎么样.这实际上是测试类型T,但是使用obj参数纯粹用于泛型类型推断(以便于调用) - obj尽管如此,它在没有param的情况下几乎完全相同.

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
}

但是如果你已经将值装入对象变量,那么这将不会很好.

Answer 2

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

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

Answer 3

"如何检查类型是否可以为空"的问题？实际上是"如何检查类型是否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

如果你想检查对象是否可以为空,而不是a Type,那么你可以将上述技术与Marc Gravell的解决方案一起使用来创建一个相当简单的方法:

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

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

Answer 4

这对我有用,看起来很简单:

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

Answer 5

好吧,你可以使用:

return !(o is ValueType);

...但是一个对象本身不是可空的,否则 - 一个类型.你打算怎么用这个？

Answer 6

我能想到的最简单的方法是:

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

Answer 7

这里有两个问题:1)测试以查看Type是否可为空; 2)测试一个对象是否代表一个可空类型.

对于问题1(测试类型),这是我在自己的系统中使用的解决方案:TypeIsNullable-check解决方案

对于问题2(测试对象),Dean Chalk上面的解决方案适用于值类型,但它不适用于引用类型,因为使用<T>重载总是返回false.由于引用类型本质上是可空的,因此测试引用类型应始终返回true.有关这些语义的解释,请参阅下面的注释[关于"nullability"].因此,这是我对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> -type参数时选择先前显示的第二个方法重载所需的处理器时间长得多.因此,最佳解决方案是使用此处所示的双方法方法.

CAVEAT:只有在使用原始对象引用或精确副本调用时,此方法才能可靠地工作,如示例所示.但是,如果可空对象被装箱到另一个类型(例如对象等)而不是保留在其原始的Nullable <>形式中,则此方法将无法可靠地工作.如果调用此方法的代码未使用原始的,未装箱的对象引用或精确副本,则无法使用此方法可靠地确定对象的可为空性.

在大多数编码场景中,为了确定可空性,必须依赖于测试原始对象的类型,而不是其参考(例如,代码必须能够访问对象的原始类型以确定可为空性).在这些更常见的情况下,IsTypeNullable(请参阅链接)是确定可为空性的可靠方法.

PS - 关于"可空性"

我应该在一个单独的帖子中重复关于可空性的声明,该声明直接适用于正确解决这个问题.也就是说,我认为这里讨论的重点不应该是如何检查一个对象是否是一个通用的Nullable类型,而是一个人是否可以为其类型的对象赋值null.换句话说,我认为我们应该确定一个对象类型是否可以为空,而不是它是否为Nullable.区别在于语义,即确定可空性的实际原因,这通常都很重要.

在使用类型可能未知的对象直到运行时(Web服务,远程调用,数据库,提要等)的系统中,常见的要求是确定是否可以为对象分配null,或者对象是否可能包含一个null.在非可空类型上执行此类操作可能会产生错误,通常是异常,这在性能和编码要求方面都非常昂贵.为了采取主动避免此类问题的高度优选方法,有必要确定任意类型的对象是否能够包含空值; 即,它是否通常是"可空的".

在一个非常实际和典型的意义上,.NET术语中的可空性并不一定意味着对象的Type是Nullable的一种形式.事实上,在很多情况下,对象具有引用类型,可以包含空值,因此都可以为空; 这些都没有Nullable类型.因此,出于实际目的,在大多数情况下,应该针对可空性的一般概念进行测试,而不是Nullable的依赖于实现的概念.所以我们不应该只关注.NET Nullable类型,而应该在关注可空性的一般实用概念的过程中结合我们对其要求和行为的理解.

Answer 8

我提出的最简单的解决方案是实现Microsoft的解决方案(如何:识别可空类型(C#编程指南))作为扩展方法:

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

然后可以这样调用:

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

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

Answer 9

在装入可空类型(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))

它成为一个真正的引用类型,所以你失去了它可以为空的事实.