propiedad - saber si es numero o letra c#

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

Question

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 forma de verificar si un tipo es una subclase OR de la clase base en sí, sin usar un operador OR o usar un método de extensión?

Answer 1

Al parecer, no.

Aquí están las opciones:

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

Tipo.IsSubclassOf

Como ya descubrió, esto no funcionará si los dos tipos son iguales, aquí hay un ejemplo del programa LINQPad 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 es (obviamente) una subclase de sí mismo.

Tipo.IsAssignableFrom

Ahora, esto responderá a su pregunta en particular, pero también le dará falsos positivos. Como Eric Lippert ha señalado en los comentarios, si bien el método devolverá True para las dos preguntas anteriores, también lo hará con True , lo 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í se obtiene la siguiente salida:

True
True
True

El último True indicaría, si el método solo respondiera a la pregunta formulada, que uint[] hereda de int[] o que sean del mismo tipo, lo que claramente no es el caso.

Así que IsAssignableFrom 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 que no trabaje con los objetos de Type .

En otras palabras, esto no compilará:

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

ni tampoco esto:

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

ni tampoco 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);

lo que por supuesto tiene más sentido en un método:

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

Answer 2

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

Answer 3

Estoy publicando esta respuesta con la esperanza de que alguien comparta conmigo si y por qué sería una mala idea. En mi solicitud, 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. Así que 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í, así que cualquier comentario sería bienvenido.

Answer 4

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

Error: ''Tipo'' no contiene una definición para ''IsAssignableFrom'' y no se puede encontrar un 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 IsAssignableFrom solicita un objeto TypeInfo . Puede usar el método GetTypeInfo() de System.Reflection :

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

Answer 5

typeof(BaseClass).IsAssignableFrom(unknownType);