如何确定对象是否继承自抽象泛型类

Question

I have a generic abstract class which I derive from:

abstract class SuperClass<T>
where T : SuperDataClass

abstract class SuperDataClass

The data type is limited to SuperDataClass, so every concrete data type must inherit from SuperDataClass. In the end I have pairs of SuperClass and SuperDataClass inheriters, eg:

class DataClassA : SuperDataClass
class ClassA : SuperClass<DataClassA>

class DataClassB : SuperDataClass
class ClassB : SuperClass<DataClassB>

How can I check if an object, eg ClassA inherits from SuperClass without knowing the possible data type?

I tried the following, which does not work:

if (testObject.GetType().IsAssignableFrom(typeof(SuperClass<SuperDataClass>))) {
    Console.WriteLine("The test object inherits from SuperClass");
}

So how does the if-statement needs to look like?

Answer 1

Use the IsSubclassOf function in conjunction with the generic type:

if (@object.GetType().IsGenericType &&
    @object.GetType().GetGenericTypeDefinition().IsSubclassOf(typeof(SuperClass<>))) {
    Console.WriteLine("The object inherits from SuperClass");
}

Where @object is the type you want to check (i copied the naming from your question, but object is no good name because it's the superclass of all classes).

If you want to check the generic type param as well, use

if (@object.GetType().IsGenericType &&  
    @object.GetType().GenericTypeArguments[0].IsSubclassOf(typeof(SuperDataClass)) && 
    @object.GetType().IsSubclassOf(typeof(Superclass<>)))

EDIT: your last comment - non generic type deriving from generic type:

if (@object.GetType().IsSubclassOf(typeof(Superclass<>)))

Answer 2

Recursively

Type type2 = type; // type is your type, like typeof(ClassA)

while (type2 != null)
{
    if (type2.IsGenericType && 
        type2.GetGenericTypeDefinition() == typeof(SuperClass<>))
    {
        // found
    }

    type2 = type2.BaseType;
}

Note that this won't work if you are looking for an interface!

Answer 3

Apparently all obvious solutions ( IsSubclassOf , IsAssignableFrom , is , as ) do not work in this case. So I tried to force things a bit and came up with this way of testing if a class is SuperClass<Something> :

private bool IsSuperClassOfSomeKindOfSuperDataClass(Type type)
{
    if (!type.IsGenericType)
        return false;

    var gtd = type.GetGenericTypeDefinition();

    if (gtd != typeof(SuperClass<>))
        return false;

    var genericParameter = type.GetGenericArguments().First();

    return genericParameter.IsSubclassOf(typeof(SuperDataClass));
}

Of course, this tests if a class is SuperClass<Something> , not if it inherits from SuperClass<Something> , so the next obvious step would be to write a function that tests all inheritance hierarchy for a suitable class:

private bool InheritsFromSuperClassOfSomeKindOfSuperDataClass(Type type)
{
    while (type != typeof(Object))
    {
        if (IsSuperClassOfSomeKindOfSuperDataClass(type))
            return true;

        type = type.BaseType;
    }

    return false;
}

With these functions in place, the test you're looking for is:

if (InheritsFromSuperClassOfSomeKindOfSuperDataClass(@object.GetType())) 
    // do stuff...

Answer 4

Here you should have some clue as to what the expected type is. So in this case I would use the Type.IsSubclassOf Method .

An example of it's use is

Class1 myClass = new Class1();
DerivedC1 myDClass = new DerivedC1();
Type myClassType = myClass.GetType();
Type myDClassType = myDClass.GetType();

// Returns true.
bool isSubClass = myDClassType.IsSubclassOf(myClassType));

I hope this helps.