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

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

然后可以这样调用:

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

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

nullable有两种类型:nullable <T>和reference-type。

Jon纠正了我，如果是盒装的，很难得到类型，但你可以用泛型: 那么下面呢?这实际上是在测试类型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
}

但是如果你已经将值装箱到一个对象变量中，这就不能很好地工作了。

微软文档:https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/nullable-types/how-to-identify-a-nullable-type

我认为使用微软对IsGenericType的建议测试是好的，但在GetUnderlyingType的代码中，微软使用了一个额外的测试，以确保你没有通过泛型类型定义Nullable<>:

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

最简单的方法是:

public bool IsNullable(object obj)
{
    Type t = obj.GetType();
    return t.IsGenericType 
        && 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))

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

“如何检查一个类型是否为空”的问题实际上是“如何检查一个类型是否为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<>);
}