检查类是否派生自泛型类

(由于大量重写而重新发布)

JaredPar的代码答案很棒,但是如果您的泛型类型不是基于值类型参数,那么我有一个提示会使它变得不必要.我被挂断了为什么"是"操作员不能工作,所以我也记录了我的实验结果以供将来参考.请加强此答案以进一步提高其清晰度.

小费:

如果你确定你的GenericClass实现继承了一个抽象的非泛型基类,比如GenericClassBase,你可以毫无困难地问同样的问题:

typeof(Test).IsSubclassOf(typeof(GenericClassBase))

IsSubclassOf()

我的测试表明IsSubclassOf()不适用于无参数泛型类型,例如

typeof(GenericClass<>)

而它会合作

typeof(GenericClass)

因此,以下代码适用于GenericClass <>的任何派生,假设您愿意基于SomeType进行测试:

typeof(Test).IsSubclassOf(typeof(GenericClass))

我唯一想象你想要通过GenericClass <>进行测试的是插件框架场景.

关于"是"算子的思考

在设计时,C#不允许使用无参数泛型,因为它们在那时基本上不是完整的CLR类型.因此,您必须使用参数声明泛型变量,这就是"is"运算符对于处理对象非常强大的原因.顺便说一句,"是"运算符也不能评估无参数的泛型类型.

"is"运算符将测试整个继承链,包括接口.

因此,给定任何对象的实例,以下方法将起到作用:

bool IsTypeof(object t)
{
    return (t is T);
}

这有点多余,但我想我会继续为每个人想象它.

特定

var t = new Test();

以下代码行将返回true:

bool test1 = IsTypeof>(t);

bool test2 = IsTypeof>(t);

bool test3 = IsTypeof(t);

另一方面,如果你想要特定于Ge​​nericClass的东西,你可以使它更具体,我想,像这样:

bool IsTypeofGenericClass(object t)
{
    return (t is GenericClass);
}

然后你会像这样测试:

bool test1 = IsTypeofGenericClass(t);

我研究了一些样本,发现在某些情况下它们缺乏.此版本适用于各种泛型:类型,接口和类型定义.

public static bool InheritsOrImplements(this Type child, Type parent)
{
    parent = ResolveGenericTypeDefinition(parent);

    var currentChild = child.IsGenericType
                           ? child.GetGenericTypeDefinition()
                           : child;

    while (currentChild != typeof (object))
    {
        if (parent == currentChild || HasAnyInterfaces(parent, currentChild))
            return true;

        currentChild = currentChild.BaseType != null
                       && currentChild.BaseType.IsGenericType
                           ? currentChild.BaseType.GetGenericTypeDefinition()
                           : currentChild.BaseType;

        if (currentChild == null)
            return false;
    }
    return false;
}

private static bool HasAnyInterfaces(Type parent, Type child)
{
    return child.GetInterfaces()
        .Any(childInterface =>
        {
            var currentInterface = childInterface.IsGenericType
                ? childInterface.GetGenericTypeDefinition()
                : childInterface;

            return currentInterface == parent;
        });
}

private static Type ResolveGenericTypeDefinition(Type parent)
{
    var shouldUseGenericType = true;
    if (parent.IsGenericType && parent.GetGenericTypeDefinition() != parent)
        shouldUseGenericType = false;

    if (parent.IsGenericType && shouldUseGenericType)
        parent = parent.GetGenericTypeDefinition();
    return parent;
}

以下是单元测试:

protected interface IFooInterface
{
}

protected interface IGenericFooInterface
{
}

protected class FooBase
{
}

protected class FooImplementor
    : FooBase, IFooInterface
{
}

protected class GenericFooBase
    : FooImplementor, IGenericFooInterface