Prüfen, ob eine Klasse von einer generischen Klasse abgeleitet ist

Question

Ich habe eine generische Klasse in meinem Projekt mit abgeleiteten Klassen.

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

public class Test : GenericClass<SomeType>
{
}

Gibt es eine Möglichkeit, herauszufinden, ob ein Type Objekt ist abgeleitet von GenericClass ?

t.IsSubclassOf(typeof(GenericClass<>))

funktioniert nicht.

Answer 1

Ich komme zu spät. Auch ich habe eine andere Variante der Antwort von JarodPar.

hier ist Type.IsSubClassOf(Type) mit freundlicher Genehmigung von reflector:

    public virtual bool IsSubclassOf(Type c)
    {
        Type baseType = this;
        if (!(baseType == c))
        {
            while (baseType != null)
            {
                if (baseType == c)
                {
                    return true;
                }
                baseType = baseType.BaseType;
            }
            return false;
        }
        return false;
    }

Daraus ersehen wir, dass es nicht etwas zu cray cray und ist ähnlich wie JaredPar's iterativen Ansatz. so weit, so gut. hier ist meine Version (Disclaimer: nicht gründlich getestet, so lemme wissen, wenn Sie Probleme finden)

    public static bool IsExtension(this Type thisType, Type potentialSuperType)
    {
        //
        // protect ya neck
        //
        if (thisType == null || potentialSuperType == null || thisType == potentialSuperType) return false;

        //
        // don't need to traverse inheritance for interface extension, so check/do these first
        //
        if (potentialSuperType.IsInterface)
        {
            foreach (var interfaceType in thisType.GetInterfaces())
            {
                var tempType = interfaceType.IsGenericType ? interfaceType.GetGenericTypeDefinition() : interfaceType;

                if (tempType == potentialSuperType)
                {
                    return true;
                }
            }
        }

        //
        // do the concrete type checks, iterating up the inheritance chain, as in orignal
        //
        while (thisType != null && thisType != typeof(object))
        {
            var cur = thisType.IsGenericType ? thisType.GetGenericTypeDefinition() : thisType;

            if (potentialSuperType == cur)
            {
                return true;
            }

            thisType = thisType.BaseType;
        }
        return false;
    }

Im Grunde ist dies nur eine Erweiterungsmethode zu System.Type - ich tat dies, um absichtlich die "thisType" Typ zu konkreten Typen zu begrenzen, wie meine unmittelbare Verwendung ist LINQ Abfrage "wo" Prädikate gegen Type-Objekte. ich bin sicher, dass alle Sie intelligente Leute da draußen es zu einem effizienten, Allzweck statische Methode knallen könnte, wenn Sie benötigen:) der Code tut ein paar Dinge, die die Antwort Code doesn't

1. ist offen für allgemeine "Erweiterungen" - ich denke an Vererbung (denke an Klassen) als auch die Implementierung (Schnittstellen); Methoden- und Parameternamen werden geändert, um dies besser widerzuspiegeln
2. Eingabe-Null-Prüfung (meah)
3. Eingabe des gleichen Typs (eine Klasse kann sich nicht selbst erweitern)
4. die Ausführung abkürzen, wenn es sich bei dem fraglichen Typ um eine Schnittstelle handelt; da GetInterfaces() alle implementierten Schnittstellen zurückgibt (auch solche, die in Superklassen implementiert sind), können Sie einfach eine Schleife durch diese Sammlung ziehen, ohne den Vererbungsbaum erklimmen zu müssen

der Rest ist im Grunde derselbe wie der Code von JaredPar