¿Cómo verifico si un tipo es un subtipo O el tipo de un objeto?

Para verificar si un tipo es una subclase de otro tipo en C #, es fácil:

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

Sin embargo, esto fallará:

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

¿Hay alguna manera de verificar si un tipo es una subclase O de la clase base en sí, sin usar un ORoperador o un método de extensión?

Aparentemente no.

Aquí están las opciones:

• Use Type.IsSubclassOf
• Use Type.IsAssignableFrom
• is y as

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 Derivedes 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á Truepara las dos preguntas anteriores, también regresará Truepara 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 Trueallí 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 IsAssignableFromlo tanto, tampoco es del todo correcto.

is y as

El "problema" con isy asen 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 Typeobjetos.

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

typeof(BaseClass).IsAssignableFrom(unknownType);

Deberías intentar usar Type.IsAssignableFrom en su lugar.

Si está intentando hacerlo en un proyecto PCL de Xamarin Forms, las soluciones anteriores que se utilizan IsAssignableFromdan un error:

Error: 'Tipo' no contiene una definición para 'IsAssignableFrom' y no se puede encontrar ningún método de extensión 'IsAssignableFrom' que acepte un primer argumento de tipo 'Tipo' (¿falta una directiva de uso o una referencia de ensamblado?)

porque IsAssignableFrompide un TypeInfoobjeto Puedes usar el GetTypeInfo()método desde System.Reflection:

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

Estoy publicando esta respuesta con la esperanza de que alguien comparta conmigo si y por qué sería una mala idea. En mi aplicación, tengo una propiedad de Tipo que quiero verificar para asegurarme de que es typeof (A) o typeof (B), donde B es cualquier clase derivada de A. Entonces mi código:

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

Siento que podría ser un poco ingenuo aquí, por lo que cualquier comentario sería bienvenido.