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

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

then

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> a nullable <>?”，而且还回答了“是否为List<int> a List<>?”

大多数提供的解决方案使用Nullable. getunderlyingtype()方法，该方法显然只适用于Nullable<>的情况。我没有看到适用于任何泛型类型的一般反射解决方案，所以我决定在这里添加它以供后人使用，尽管这个问题很久以前就已经有了答案。

要使用反射检查类型是否为Nullable<>的某种形式，首先必须将构造的泛型类型(例如Nullable<int>)转换为泛型类型定义Nullable<>。您可以通过使用Type类的GetGenericTypeDefinition()方法来做到这一点。然后你可以将结果类型与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

如果你想检查一个对象是否为空，而不是一个类型，那么你可以使用上面的技术和Marc Gravell的解决方案来创建一个相当简单的方法:

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

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

当装箱一个可空类型(nullable <int> or 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))

它变成了一个真正的引用类型，所以你失去了它是可空的事实。

这个版本:

缓存结果更快， 不需要不必要的变量，如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;

也许有点偏离主题，但仍然是一些有趣的信息。我发现很多人使用nullable. getunderlyingtype () != null来标识类型是否为空。这显然是可行的，但微软建议以下类型。IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)(参见http://msdn.microsoft.com/en-us/library/ms366789.aspx)。

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

nulable . getunderlyingtype (): 1335ms(慢3倍)

GetGenericTypeDefinition() == typeof(Nullable<>): 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();
}

我想到的最简单的解决方案是实现微软的解决方案(如何:识别可空类型(c#编程指南))作为扩展方法:

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

然后可以这样调用:

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

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