How could I know if an object is derived from a specific generic class?

Question

Suppose that I have an object then how could I know if the object is derived from a specific generic class. For example:

public class GenericClass<T> 
{
}    

public bool IsDeriveFrom(object o)
{
    return o.GetType().IsSubclassOf(typeof(GenericClass)); //will throw exception here
}

please notice that the code above will throw an exception. The type of the generic class cannot be retrieved directly because there is no type for a generic class without a type parameter provided.

Answer 1

Your should do something like this:

    public class GenericClass<T>
    {
    }

    public class GenericClassInherited<T> : GenericClass<T>
    {
    }


    public static bool IsDeriveFrom(object o)
    {
        return o.GetType().BaseType.GetGenericTypeDefinition() == typeof(GenericClass<>);
    }

Example:

    static void Main(string[] args)
    {
        var generic = new GenericClassInherited<int>();
        var isTrue = IsDeriveFrom(generic);
    }

Answer 2

bool IsDerivedFrom(Type type, Type genericBaseTypeDefinition) {
    Contract.Requires(type != null);
    Contract.Requires(genericBaseTypeDefinition != null);
    Contract.Requires(genericBaseTypeDefinition.IsGenericBaseTypeDefinition);
    Type baseType = type.BaseType;
    if (baseType == null) {
        return false;
    }

    if (baseType.IsGenericType) {
        Type generic = baseType.GetGenericTypeDefinition();
        if (generic == null) {
            return false;
        }
        return generic == genericBaseTypeDefinition;
    }

    return IsDerivedFrom(baseType, genericBaseTypeDefinition);
}

Usage:

bool derived = IsDerivedFrom(typeof(Foo), typeof(GenericFoo<>));

These tests pass:

class GenericFoo<T> { }
class DerivedGenericFoo<T> : GenericFoo<T> { }
class Foo : GenericFoo<int> { }
class Bar : Foo { }
class Animal { }

[Fact]
public void DerivedGenericFoo_derives_from_open_GenericFoo() {
    Assert.Equal(
        true,
        IsDerivedFrom(
            typeof(DerivedGenericFoo<int>),
            typeof(GenericFoo<>)
        )
    );
}

[Fact]
public void Foo_derives_from_open_GenericFoo() {
    Assert.Equal(true, IsDerivedFrom(typeof(Foo), typeof(GenericFoo<>)));
}

[Fact]
public void Bar_derives_from_open_GenericFoo() {
    Assert.Equal(true, IsDerivedFrom(typeof(Bar), typeof(GenericFoo<>)));
}

[Fact]
public void Animal_does_not_derive_from_open_GenericFoo() {
    Assert.Equal(false, IsDerivedFrom(typeof(Animal), typeof(GenericFoo<>)));
}