Trouver tous les types parents (à la fois les classes de base et les interfaces)

Je veux être en mesure de trouver tous les parents de types (classes de base et des interfaces) pour un type spécifique.

Par exemple si j'ai

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

je veux voir qu'Une est B, C, D et E et de l'Objet

Quel est le meilleur moyen pour ce faire? est-il une méthode de réflexion pour ce faire ou dois-je le faire moi-même quelque chose.

====EDIT====

Donc quelque chose comme cela?

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

J'ai été un peu en espérant que je n'ai pas eu à le faire moi-même mais bon.

source d'informationauteur Luke McGregor | 2012-01-15

  1. 23

    Plus de solution générale:

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

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

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

    Ou à réellement obtenir tous les parents de types:

    public static IEnumerable<Type> GetParentTypes(this Type type)
{
    //is there any base type?
    if (type == 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;
    }
}
  2. 6

    Pour obtenir les interfaces implémentées par un type, l'utilisation Type.GetInterfaces. À voir de sa de classe de la hiérarchie, vous pouvez utiliser Type.BaseType de manière itérative jusqu'à ce que vous frappez une nullde référence (généralement ce qui se passera après vous frappez System.Objectmais pas nécessairement - par exemple, une interface de type de type de base sera directement null).

  3. 5

    Un C# méthode d'extension pour les paresseux:

    ///<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;
}
  4. 2

    Pour les interfaces, typeof(A).GetInterfaces() (documentée ici: http://msdn.microsoft.com/en-us/library/system.type.getinterfaces.aspx).

    Pour la classe de base, typeof(A).BaseType (documentée ici: http://msdn.microsoft.com/en-us/library/system.type.basetype.aspx).

    Appeler récursivement, laver, rincer, répéter.

  5. 1
    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);
}