Aparentemente no.
Aquí están las opciones:
Type.IsSubclassOf
Como ya ha descubierto, esto no funcionará si los dos tipos son iguales, aquí hay un programa LINQPad de muestra que demuestra:
void Main()
{
typeof(Derived).IsSubclassOf(typeof(Base)).Dump();
typeof(Base).IsSubclassOf(typeof(Base)).Dump();
}
public class Base { }
public class Derived : Base { }
Salida:
True
False
Lo que indica que Derived
es una subclase de Base
, pero que Base
(obviamente) no es una subclase de sí misma.
Type.IsAssignableFrom
Ahora, esto responderá a su pregunta particular, pero también le dará falsos positivos. Como Eric Lippert ha señalado en los comentarios, si bien el método realmente regresará True
para las dos preguntas anteriores, también regresará True
para estas, que probablemente no desee:
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 { }
Aquí obtienes el siguiente resultado:
True
True
True
Lo último True
allí indicaría, si el método solo responde a la pregunta formulada, que uint[]
hereda int[]
o que son del mismo tipo, lo que claramente no es el caso.
Por IsAssignableFrom
lo tanto, tampoco es del todo correcto.
is
y as
El "problema" con is
y as
en el contexto de su pregunta es que requerirán que opere en los objetos y escriba uno de los tipos directamente en el código, y no trabaje con Type
objetos.
En otras palabras, esto no compilará:
SubClass is BaseClass
^--+---^
|
+-- need object reference here
ni esto:
typeof(SubClass) is typeof(BaseClass)
^-------+-------^
|
+-- need type name here, not Type object
ni esto:
typeof(SubClass) is BaseClass
^------+-------^
|
+-- this returns a Type object, And "System.Type" does not
inherit from BaseClass
Conclusión
Si bien los métodos anteriores pueden ajustarse a sus necesidades, la única respuesta correcta a su pregunta (tal como la veo) es que necesitará una verificación adicional:
typeof(Derived).IsSubclassOf(typeof(Base)) || typeof(Derived) == typeof(Base);
que por supuesto tiene más sentido en un método:
public bool IsSameOrSubclass(Type potentialBase, Type potentialDescendant)
{
return potentialDescendant.IsSubclassOf(potentialBase)
|| potentialDescendant == potentialBase;
}