CODEWITHSUNDEEP
c#.netgenerics
Edison Chuang
Edison Chuang

Reputation: 2921

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

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.

Upvotes: 6

Views: 775

Answers (3)

Roman Starkov
Roman Starkov

Reputation: 61382

The key is Type.GetGenericTypeDefinition. Here's a complete example:

class Generic<T> { }

class Derived<T> : Generic<T> { }
class NonDerived<T> { }

class Program
{
    static bool IsDerivedFromGenericT(Type type)
    {
        if (!type.IsGenericType)
            return false;
        if (type.GetGenericTypeDefinition() == typeof(Generic<>))
            return true;
        if (type.BaseType == null)
            return false;
        return IsDerivedFromGenericT(type.BaseType);
    }

    static void Main(string[] args)
    {
        var b1 = IsDerivedFromGenericT(new Derived<int>().GetType()); // true
        var b2 = IsDerivedFromGenericT(new Derived<string>().GetType()); // true
        var b3 = IsDerivedFromGenericT(new NonDerived<string>().GetType()); // false
    }
}

Upvotes: 1

jason
jason

Reputation: 241583

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<>)));
}

Upvotes: 2

Andrew Orsich
Andrew Orsich

Reputation: 53675

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);
    }

Upvotes: 2

Related Questions