Trova tutti i tipi principali (entrambe le classi di base e le interfacce)

Question

Desidero essere in grado di trovare tutti i tipi principali (classi di base e interfacce) per un tipo specifico.

EG se ho

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

voglio vedere che A è B C D ed E e oggetto

cosa è il modo migliore per fare questo? c'è un metodo di riflessione per fare questo o ho bisogno di farmi qualcosa.

==== ==== EDIT

Quindi qualcosa di simile?

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

Stavo sperando di non doverlo fare da solo, ma vabbè.

Answer 1

Più soluzione generale:

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 per ottenere effettivamente tutti i tipi di genitore:

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

Per ottenere le interfacce implementate da un tipo, utilizzare Type.GetInterfaces. Per vedere la sua gerarchia di classi, è possibile utilizzare Type.BaseType iterativamente fino a quando non si preme un riferimento null (in genere ciò avverrà dopo aver colpito System.Object, ma non necessariamente - ad esempio, il tipo di base di un tipo di interfaccia sarà direttamente null).

Answer 3

Per interfacce, typeof(A).GetInterfaces() (documentato qui: http://msdn.microsoft.com/en-us/library/system.type.getinterfaces.aspx).

Per la classe base, typeof(A).BaseType (documentato qui: http://msdn.microsoft.com/en-us/library/system.type.basetype.aspx).

Chiamare in modo ricorsivo, lavare, risciacquare, ripetere.

Answer 4

A C# metodo di estensione per i pigri:

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