Buscar todos los tipos principales (tanto las clases base como las interfaces)

Question

Deseo poder encontrar todos los tipos principales (clases base e interfaces) para un tipo específico.

por ejemplo, si tengo

class A : B, C { } 
class B : D { } 
interface C : E { } 
class D { } 
interface E { } 

quiero ver que A es B C D y E y el objeto

Cuál es la mejor manera de hacer esto? hay un método de reflexión para hacer esto o necesito hacerme algo?

==== ==== EDITAR

Así que algo como esto?

public static IEnumerable<Type> ParentTypes(this Type type) 
    { 
     foreach (Type i in type.GetInterfaces()) 
     { 
      yield return i; 
      foreach (Type t in i.ParentTypes()) 
      { 
       yield return t; 
      } 
     } 

     if (type.BaseType != null) 
     { 
      yield return type.BaseType; 
      foreach (Type b in type.BaseType.ParentTypes()) 
      { 
       yield return b; 
      } 
     } 
    } 

Estaba esperando que no tuviera que hacerlo yo solo, pero bueno.

Answer 1

Más solución general:

public static bool InheritsFrom(this Type type, Type baseType) 
{ 
    // null does not have base type 
    if (type == null) 
    { 
     return false; 
    } 

    // only interface can have null base type 
    if (baseType == null) 
    { 
     return type.IsInterface; 
    } 

    // check implemented interfaces 
    if (baseType.IsInterface) 
    { 
     return type.GetInterfaces().Contains(baseType); 
    } 

    // check all base types 
    var currentType = type; 
    while (currentType != null) 
    { 
     if (currentType.BaseType == baseType) 
     { 
      return true; 
     } 

     currentType = currentType.BaseType; 
    } 

    return false; 
} 

O para conseguir realmente todos los tipos de padres:

public static IEnumerable<Type> GetParentTypes(this Type type) 
{ 
    // is there any base type? 
    if ((type == null) || (type.BaseType == null)) 
    { 
     yield break; 
    } 

    // return all implemented or inherited interfaces 
    foreach (var i in type.GetInterfaces()) 
    { 
     yield return i; 
    } 

    // return all inherited types 
    var currentBaseType = type.BaseType; 
    while (currentBaseType != null) 
    { 
     yield return currentBaseType; 
     currentBaseType= currentBaseType.BaseType; 
    } 
} 

Answer 2

Para obtener las interfaces implementadas por un tipo, use Type.GetInterfaces. Para ver su jerarquía de clases, puede usar Type.BaseType de forma iterativa hasta llegar a null -reference (normalmente esto sucederá después de presionar System.Object, pero no necesariamente; por ejemplo, el tipo de base de un tipo de interfaz será directamente null).

Answer 3

Para interfaces, typeof(A).GetInterfaces() (documentado aquí: http://msdn.microsoft.com/en-us/library/system.type.getinterfaces.aspx).

Para la clase base, typeof(A).BaseType (documentado aquí: http://msdn.microsoft.com/en-us/library/system.type.basetype.aspx).

Llamar recursivamente, lavar, enjuagar, repetir.

Answer 4

Un método de C# de extensión para los perezosos:

/// <summary> 
/// Extension method to check the entire inheritance hierarchy of a 
/// type to see whether the given base type is inherited. 
/// </summary> 
/// <param name="t">The Type object this method was called on</param> 
/// <param name="baseType">The base type to look for in the 
/// inheritance hierarchy</param> 
/// <returns>True if baseType is found somewhere in the inheritance 
/// hierarchy, false if not</returns> 
public static bool InheritsFrom(this Type t, Type baseType) 
{ 
    Type cur = t.BaseType; 

    while (cur != null) 
    { 
     if (cur.Equals(baseType)) 
     { 
      return true; 
     } 

     cur = cur.BaseType; 
    } 

    return false; 
} 

Answer 5

public static bool IsSubclassOfTypeOrInterface(this Type type, Type ofTypeOrInterface) 
{ 
    if (type == null) 
    { 
     throw new ArgumentNullException("type"); 
    } 
    if (ofTypeOrInterface == null) 
    { 
     throw new ArgumentNullException("ofTypeOrInterface"); 
    } 

    return ofTypeOrInterface.IsInterface 
       ? type.GetInterfaces().Contains(ofTypeOrInterface) 
       : type.IsSubclassOf(ofTypeOrInterface); 
}