Wie überprüfe ich, ob ein Typ ein Subtyp oder der Typ eines Objekts ist?

Um zu überprüfen, ob ein Typ eine Unterklasse eines anderen Typs in C # ist, ist es einfach:

typeof (SubClass).IsSubclassOf(typeof (BaseClass)); // returns true

Dies wird jedoch fehlschlagen:

typeof (BaseClass).IsSubclassOf(typeof (BaseClass)); // returns false

Gibt es eine Möglichkeit zu überprüfen, ob ein Typ entweder eine Unterklasse ODER der Basisklasse selbst ist, ohne einen OROperator oder eine Erweiterungsmethode zu verwenden?

Anscheinend nein.

Hier sind die Optionen:

• Verwenden Sie Type.IsSubclassOf
• Verwenden Sie Type.IsAssignableFrom
• is und as

Type.IsSubclassOf

Wie Sie bereits herausgefunden haben, funktioniert dies nicht, wenn die beiden Typen identisch sind. Hier ist ein Beispiel für ein LINQPad- Programm, das Folgendes demonstriert:

void Main()
{
    typeof(Derived).IsSubclassOf(typeof(Base)).Dump();
    typeof(Base).IsSubclassOf(typeof(Base)).Dump();
}

public class Base { }
public class Derived : Base { }

Ausgabe:

True
False

Was darauf hinweist, dass dies Derivedeine Unterklasse von ist Base, aber das Baseist (offensichtlich) keine Unterklasse von sich.

Type.IsAssignableFrom

Dies wird Ihre spezielle Frage beantworten, aber es wird Ihnen auch falsch positive Ergebnisse liefern. Wie Eric Lippert in den Kommentaren ausgeführt hat, wird die Methode zwar Truefür die beiden oben genannten Fragen zurückkehren, aber auch Truefür diese, die Sie wahrscheinlich nicht wollen:

void Main()
{
    typeof(Base).IsAssignableFrom(typeof(Derived)).Dump();
    typeof(Base).IsAssignableFrom(typeof(Base)).Dump();
    typeof(int[]).IsAssignableFrom(typeof(uint[])).Dump();
}

public class Base { }
public class Derived : Base { }

Hier erhalten Sie folgende Ausgabe:

True
True
True

Das letzte Truedort würde anzeigen, wenn die Methode nur die gestellte Frage beantwortet, uint[]die von int[]oder vom gleichen Typ erbt , was eindeutig nicht der Fall ist.

Ist IsAssignableFromalso auch nicht ganz richtig.

is und as

Das "Problem" mit isund asim Kontext Ihrer Frage besteht darin, dass Sie die Objekte bearbeiten und einen der Typen direkt in Code schreiben müssen und nicht mit TypeObjekten arbeiten müssen.

Mit anderen Worten, dies wird nicht kompiliert:

SubClass is BaseClass
^--+---^
   |
   +-- need object reference here

noch wird dies:

typeof(SubClass) is typeof(BaseClass)
                    ^-------+-------^
                            |
                            +-- need type name here, not Type object

noch wird dies:

typeof(SubClass) is BaseClass
^------+-------^
       |
       +-- this returns a Type object, And "System.Type" does not
           inherit from BaseClass

Fazit

Während die oben genannten Methoden möglicherweise Ihren Anforderungen entsprechen, ist die einzig richtige Antwort auf Ihre Frage (wie ich es sehe), dass Sie eine zusätzliche Prüfung benötigen:

typeof(Derived).IsSubclassOf(typeof(Base)) || typeof(Derived) == typeof(Base);

was in einer Methode natürlich sinnvoller ist:

public bool IsSameOrSubclass(Type potentialBase, Type potentialDescendant)
{
    return potentialDescendant.IsSubclassOf(potentialBase)
           || potentialDescendant == potentialBase;
}

typeof(BaseClass).IsAssignableFrom(unknownType);

Sie sollten stattdessen Type.IsAssignableFrom verwenden.

Wenn Sie versuchen, dies in einem Xamarin Forms PCL-Projekt zu tun, geben die oben genannten Lösungen IsAssignableFromeinen Fehler aus:

Fehler: 'Typ' enthält keine Definition für 'IsAssignableFrom' und es konnte keine Erweiterungsmethode 'IsAssignableFrom' gefunden werden, die ein erstes Argument vom Typ 'Typ' akzeptiert (fehlt eine using-Direktive oder eine Assemblyreferenz?)

weil IsAssignableFromnach einem TypeInfoObjekt fragt . Sie können die GetTypeInfo()Methode verwenden von System.Reflection:

typeof(BaseClass).GetTypeInfo().IsAssignableFrom(typeof(unknownType).GetTypeInfo())

Ich poste diese Antwort in der Hoffnung, dass jemand mit mir teilt, ob und warum es eine schlechte Idee wäre. In meiner Anwendung habe ich eine Eigenschaft vom Typ Typ, die ich überprüfen möchte, um sicherzustellen, dass es sich um den Typ (A) oder den Typ (B) handelt, wobei B eine von A abgeleitete Klasse ist. Also mein Code:

public class A
{
}

public class B : A
{
}

public class MyClass
{
    private Type _helperType;
    public Type HelperType
    {
        get { return _helperType; }
        set 
        {
            var testInstance = (A)Activator.CreateInstance(value);
            if (testInstance==null)
                throw new InvalidCastException("HelperType must be derived from A");
            _helperType = value;
        }
    }
}

Ich fühle mich hier vielleicht ein bisschen naiv, daher wäre jedes Feedback willkommen.