Wie kann ich wissen, ob ein Objekt von einer bestimmten generischen Klasse abgeleitet ist?

Question

Angenommen, dass ich ein Objekt habe, wie könnte ich dann wissen, ob das Objekt von einer bestimmten generischen Klasse abgeleitet ist. Zum Beispiel:

public class GenericClass<T> 
{ 
}  

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

Bitte beachten Sie, dass der obige Code eine Ausnahme auslöst. Der Typ der generischen Klasse kann nicht direkt abgerufen werden, da für eine generische Klasse kein Typ ohne einen angegebenen Typparameter angegeben ist.

Answer 1

Ihr sollte so etwas tun:

public class GenericClass<T> 
    { 
    } 

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


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

Beispiel:

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

Verbrauch:

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

Diese Prüfungen bestehen:

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

Answer 3

Der Schlüssel ist Type.GetGenericTypeDefinition. Hier ist ein komplettes Beispiel:

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