在 C# 中检查对象是否属于非特定泛型类型

Question

假设我有以下课程：

public class General<T> { }

我想知道一个对象是否属于那种类型。 我知道我可以使用反射来确定对象是否属于Type.GetGenericTypeDefinition 的泛型类型，但我想避免这种情况。

是否可以执行obj is General<T> 或obj.GetType().IsAssignableFrom(typeof(General<T>)) 之类的操作？

我很惊讶我找不到类似的问题，尽管我可能在搜索中使用了错误的关键字。

Answer 1

你可以这样做：

var obj = new General<int>();
var type = obj.GetType();
var isGeneral = 
(type.IsGenericType && type.GetGenericTypeDefinition() == typeof(General<>)) ||
type.GetBaseTypes().Any(x => x.IsGenericType && 
                             x.GetGenericTypeDefinition() == typeof(General<>));

其中GetBaseTypes是以下扩展方法：

public static IEnumerable<Type> GetBaseTypes(this Type type)
{
    if (type.BaseType == null) return type.GetInterfaces();

    return new []{type}.Concat(
           Enumerable.Repeat(type.BaseType, 1)
                     .Concat(type.GetInterfaces())
                     .Concat(type.GetInterfaces().SelectMany<Type, Type>(GetBaseTypes))
                     .Concat(type.BaseType.GetBaseTypes()));
}

感谢Slacks answer

Answer 2

similarquestions 有很多答案，但它们都需要反射才能向上走类型层次结构。我怀疑没有更好的方法。如果性能很关键，缓存结果可能是一种选择。这是一个使用ConcurrentDictionary 作为简单缓存的示例。然后将成本降低为简单的类型查找（通过GetType）和缓存初始化后的ConcurrentDictionary 查找。

using System.Collections.Concurrent;

private static ConcurrentDictionary<Tuple<Type,Type>, bool> cache = new ConcurrentDictionary<Tuple<Type,Type>, bool>();

public static bool IsSubclassOfRawGeneric(this Type toCheck, Type generic) {
    var input = Tuple.Create(toCheck, generic);
    bool isSubclass = cache.GetOrAdd(input, key => IsSubclassOfRawGenericInternal(toCheck, generic));
    return isSubclass;
}

private static bool IsSubclassOfRawGenericInternal(Type toCheck, Type generic) {
    while (toCheck != null && toCheck != typeof(object)) {
        var cur = toCheck.IsGenericType ? toCheck.GetGenericTypeDefinition() : toCheck;
        if (generic == cur) {
            return true;
        }
        toCheck = toCheck.BaseType;
    }
    return false;
}

你会这样使用它：

class I : General<int> { }

object o = new I();
Console.WriteLine(o is General<int>); // true
Console.WriteLine(o.GetType().IsSubclassOfRawGeneric(typeof(General<>))); //true

Answer 3

使用类型参数实例化的泛型类型定义与其他泛型类型实例完全没有关系。它们也与泛型类型定义无关。在分配和运行时强制转换方面，它们完全不兼容。如果不是，则可能会破坏类型系统。

因此，运行时强制转换无济于事。您确实必须求助于Type.GetGenericTypeDefinition。你可以把它抽象成一个辅助函数，这样你的代码就相对干净了。

Answer 4

如果泛型类或接口的成员可以被代码使用，这些代码以更通用的形式（如 Object）持有引用，但没有可用的实际泛型类型，则此类成员应以非通用基类或接口。该框架在许多情况下未能遵守这一原则，但没有理由必须效仿他们。例如，IList<T> 之类的类型可能派生自 IListBase，其中包含或继承了以下成员：

int Count {get;}
void Delete(int index);
void Clear();
void Swap(int index1, int index2);
int Compare(int index1, int index2);
// Return an object with a `StoreToIndex(int)` method
// which would store it to the list it came from.
ListItemHolder GetItemHolder(int index);
ListFeatures Features {get;}

这些成员都不会以任何方式依赖列表中包含的项目的类型，并且可以编写方法来执行诸如排序列表之类的操作（如果它的Features 表明它是可写的并且知道如何比较items），而无需了解元素类型。如果泛型接口继承自非泛型接口，则需要非泛型函数的代码可以简单地转换为非泛型接口类型并直接使用它。

Answer 5

对于更通用的解决方案，它适用于任何父类型（基类和接口）：

    public static bool IsCompatibleWith(this Type type, Type parentType)
    {
        if (type == null)
        {
            throw new ArgumentNullException(nameof(type));
        }

        if (parentType.IsAssignableFrom(type))
        {
            return true;
        }

        return type.GetAssignableTypes()
           .Where(t => t.IsGenericType)
           .Any(t=> t.GetGenericTypeDefinition() == parentType);
    }

    /// <summary>
    /// Gets all parent types including the currrent type.
    /// </summary>
    public static IEnumerable<Type> GetAssignableTypes(this Type type)
    {
        if (type == null)
        {
            throw new ArgumentNullException(nameof(type));
        }

        // First check for interfaces because interface types don't have base classes.
        foreach (Type iType in type.GetInterfaces())
        {
            yield return iType;
        }

        // Then check for base classes.
        do
        {
            yield return type;
            type = type.BaseType;
        }
        while (type != null);
    }

想出更好的方法名称。也许称它为IsCompatibleWith 具有误导性。也许IsKindOf？此外，GetAssignableTypes 也可以称为GetParentTypes，但这也是一种误导。起名很难。记录它会更好。

---

一些测试：

IsCompatibleWith(typeof(List<int>), typeof(IList<int>))
真的

IsCompatibleWith(typeof(List<>), typeof(IList<>))
真的

IsCompatibleWith(typeof(List<int>), typeof(IList<>))
真的

IsCompatibleWith(typeof(List<int>), typeof(IList<string>))
假的