Comprobación de tipo: typeof, GetType o is?

He visto a muchas personas usar el siguiente código:

Type t = typeof(obj1);
if (t == typeof(int))
    // Some code here

Pero sé que también podrías hacer esto:

if (obj1.GetType() == typeof(int))
    // Some code here

O esto:

if (obj1 is int)
    // Some code here

Personalmente, siento que el último es el más limpio, pero ¿hay algo que me falta? ¿Cuál es el mejor para usar, o es una preferencia personal?

Todos son diferentes

• typeof toma un nombre de tipo (que especifique en tiempo de compilación).
• GetType obtiene el tipo de tiempo de ejecución de una instancia.
• is devuelve verdadero si una instancia está en el árbol de herencia.

Ejemplo

class Animal { } 
class Dog : Animal { }

void PrintTypes(Animal a) { 
    Console.WriteLine(a.GetType() == typeof(Animal)); // false 
    Console.WriteLine(a is Animal);                   // true 
    Console.WriteLine(a.GetType() == typeof(Dog));    // true
    Console.WriteLine(a is Dog);                      // true 
}

Dog spot = new Dog(); 
PrintTypes(spot);

¿Qué hay de typeof(T)? ¿También se resuelve en tiempo de compilación?

Si. T siempre es el tipo de expresión. Recuerde, un método genérico es básicamente un montón de métodos con el tipo apropiado. Ejemplo:

string Foo<T>(T parameter) { return typeof(T).Name; }

Animal probably_a_dog = new Dog();
Dog    definitely_a_dog = new Dog();

Foo(probably_a_dog); // this calls Foo<Animal> and returns "Animal"
Foo<Animal>(probably_a_dog); // this is exactly the same as above
Foo<Dog>(probably_a_dog); // !!! This will not compile. The parameter expects a Dog, you cannot pass in an Animal.

Foo(definitely_a_dog); // this calls Foo<Dog> and returns "Dog"
Foo<Dog>(definitely_a_dog); // this is exactly the same as above.
Foo<Animal>(definitely_a_dog); // this calls Foo<Animal> and returns "Animal". 
Foo((Animal)definitely_a_dog); // this does the same as above, returns "Animal"

Úselo typeofcuando desee obtener el tipo en el momento de la compilación . Úselo GetTypecuando desee obtener el tipo en el momento de la ejecución . Rara vez hay casos para usar, isya que hace un lanzamiento y, en la mayoría de los casos, terminas lanzando la variable de todos modos.

Hay una cuarta opción que no ha considerado (especialmente si también va a lanzar un objeto al tipo que encuentre); eso es para usar as.

Foo foo = obj as Foo;

if (foo != null)
    // your code here

Esto solo usa un molde mientras que este enfoque:

if (obj is Foo)
    Foo foo = (Foo)obj;

requiere dos .

Actualización (enero de 2020):

• A partir de C # 7+ , ahora puede lanzar en línea, por lo que el enfoque 'es' ahora también se puede hacer en un lanzamiento.

Ejemplo:

if(obj is Foo newLocalFoo)
{
    // For example, you can now reference 'newLocalFoo' in this local scope
    Console.WriteLine(newLocalFoo);
}

1)

Type t = typeof(obj1);
if (t == typeof(int))

Esto es ilegal, porque typeofsolo funciona en tipos, no en variables. Supongo que obj1 es una variable. Por lo tanto, de esta manera typeofes estático y funciona en tiempo de compilación en lugar de tiempo de ejecución.

2)

if (obj1.GetType() == typeof(int))

Esto es truesi obj1es exactamente de tipo int. Si obj1deriva de int, la condición if será false.

3)

if (obj1 is int)

Esto es truesi obj1es un int, o si deriva de una clase llamada int, o si implementa una interfaz llamada int.

Type t = typeof(obj1);
if (t == typeof(int))
    // Some code here

Esto es un error El operador typeof en C # solo puede tomar nombres de tipos, no objetos.

if (obj1.GetType() == typeof(int))
    // Some code here

Esto funcionará, pero quizás no como era de esperar. Para los tipos de valor, como ha mostrado aquí, es aceptable, pero para los tipos de referencia, solo devolvería verdadero si el tipo era exactamente el mismo tipo, no otra cosa en la jerarquía de herencia. Por ejemplo:

class Animal{}
class Dog : Animal{}

static void Foo(){
    object o = new Dog();

    if(o.GetType() == typeof(Animal))
        Console.WriteLine("o is an animal");
    Console.WriteLine("o is something else");
}

Esto se imprimiría "o is something else", porque el tipo de oes Dog, no Animal. Sin embargo, puede hacer que esto funcione si usa el IsAssignableFrommétodo de la Typeclase.

if(typeof(Animal).IsAssignableFrom(o.GetType())) // note use of tested type
    Console.WriteLine("o is an animal");

Sin embargo, esta técnica aún deja un gran problema. Si su variable es nula, la llamada a GetType()arrojará una NullReferenceException. Entonces, para que funcione correctamente, harías:

if(o != null && typeof(Animal).IsAssignableFrom(o.GetType()))
    Console.WriteLine("o is an animal");

Con esto, tiene un comportamiento equivalente de la ispalabra clave. Por lo tanto, si este es el comportamiento que desea, debe usar la ispalabra clave, que es más legible y más eficiente.

if(o is Animal)
    Console.WriteLine("o is an animal");

Sin embargo, en la mayoría de los casos, la ispalabra clave todavía no es lo que realmente desea, porque generalmente no es suficiente saber que un objeto es de cierto tipo. Por lo general, desea utilizar ese objeto como una instancia de ese tipo, que también requiere lanzarlo. Y entonces puede que te encuentres escribiendo código como este:

if(o is Animal)
    ((Animal)o).Speak();

Pero eso hace que el CLR verifique el tipo de objeto hasta dos veces. Lo verificará una vez para satisfacer al isoperador, y si de ohecho es un Animal, lo haremos verificar nuevamente para validar el lanzamiento.

Es más eficiente hacer esto en su lugar:

Animal a = o as Animal;
if(a != null)
    a.Speak();

El asoperador es un elenco que no lanzará una excepción si falla, sino que regresará null. De esta manera, el CLR verifica el tipo de objeto solo una vez, y después de eso, solo necesitamos hacer una verificación nula, que es más eficiente.

Pero cuidado: muchas personas caen en una trampa con as. Debido a que no arroja excepciones, algunas personas lo consideran un yeso "seguro", y lo usan exclusivamente, evitando los lanzamientos regulares. Esto lleva a errores como este:

(o as Animal).Speak();

En este caso, el desarrollador está asumiendo claramente que ohabrá siempre ser una Animal, y siempre que su suposición es correcta, todo funciona bien. Pero si están equivocados, entonces lo que terminan aquí es a NullReferenceException. Con un reparto regular, habrían obtenido un InvalidCastExceptionen su lugar, que habría identificado más correctamente el problema.

A veces, este error puede ser difícil de encontrar:

class Foo{
    readonly Animal animal;

    public Foo(object o){
        animal = o as Animal;
    }

    public void Interact(){
        animal.Speak();
    }
}

Este es otro caso en el que el desarrollador claramente espera oserlo Animalcada vez, pero esto no es obvio en el constructor, donde asse usa el elenco. No es obvio hasta que llegue al Interactmétodo, donde animalse espera que el campo se asigne positivamente. En este caso, no solo termina con una excepción engañosa, sino que no se produce hasta potencialmente mucho más tarde que cuando ocurrió el error real.

En resumen:

• Si solo necesita saber si un objeto es o no de algún tipo, úselo is.

• Si necesita tratar un objeto como una instancia de cierto tipo, pero no está seguro de que el objeto sea de ese tipo, utilícelo asy verifique null.

• Si necesita tratar un objeto como una instancia de cierto tipo, y se supone que el objeto es de ese tipo, use un molde regular.

Si está utilizando C # 7, entonces es hora de actualizar la excelente respuesta de Andrew Hare. La coincidencia de patrones ha introducido un buen acceso directo que nos da una variable tipeada dentro del contexto de la instrucción if, sin requerir una declaración / conversión y verificación por separado:

if (obj1 is int integerValue)
{
    integerValue++;
}

Esto parece bastante decepcionante para un solo elenco como este, pero realmente brilla cuando tienes muchos tipos posibles entrando en tu rutina. La siguiente es la forma antigua de evitar lanzar dos veces:

Button button = obj1 as Button;
if (button != null)
{
    // do stuff...
    return;
}
TextBox text = obj1 as TextBox;
if (text != null)
{
    // do stuff...
    return;
}
Label label = obj1 as Label;
if (label != null)
{
    // do stuff...
    return;
}
// ... and so on

Trabajar para reducir este código tanto como sea posible, así como para evitar la duplicación de lanzamientos del mismo objeto siempre me ha molestado. Lo anterior está bien comprimido con un patrón que coincide con lo siguiente:

switch (obj1)
{
    case Button button:
        // do stuff...
        break;
    case TextBox text:
        // do stuff...
        break;
    case Label label:
        // do stuff...
        break;
    // and so on...
}

EDITAR: se actualizó el nuevo método más largo para usar un interruptor según el comentario de Palec.

Tenía una Typepropiedad para comparar y no podía usar is(me gusta my_type is _BaseTypetoLookFor), pero podía usar estos:

base_type.IsInstanceOfType(derived_object);
base_type.IsAssignableFrom(derived_type);
derived_type.IsSubClassOf(base_type);

Tenga en cuenta que IsInstanceOfTypeyIsAssignableFrom regrese trueal comparar los mismos tipos, donde IsSubClassOf regresará false. Y IsSubclassOfno funciona en interfaces, donde los otros dos lo hacen. (Vea también esta pregunta y respuesta ).

public class Animal {}
public interface ITrainable {}
public class Dog : Animal, ITrainable{}

Animal dog = new Dog();

typeof(Animal).IsInstanceOfType(dog);     // true
typeof(Dog).IsInstanceOfType(dog);        // true
typeof(ITrainable).IsInstanceOfType(dog); // true

typeof(Animal).IsAssignableFrom(dog.GetType());      // true
typeof(Dog).IsAssignableFrom(dog.GetType());         // true
typeof(ITrainable).IsAssignableFrom(dog.GetType()); // true

dog.GetType().IsSubclassOf(typeof(Animal));            // true
dog.GetType().IsSubclassOf(typeof(Dog));               // false
dog.GetType().IsSubclassOf(typeof(ITrainable)); // false

yo prefiero es

Dicho esto, si estás usando es probable que no usando la herencia correctamente.

Asuma que Persona: Entidad, y ese Animal: Entidad. Feed es un método virtual en Entity (para hacer feliz a Neil)

class Person
{
  // A Person should be able to Feed
  // another Entity, but they way he feeds
  // each is different
  public override void Feed( Entity e )
  {
    if( e is Person )
    {
      // feed me
    }
    else if( e is Animal )
    {
      // ruff
    }
  }
}

Más bien

class Person
{
  public override void Feed( Person p )
  {
    // feed the person
  }
  public override void Feed( Animal a )
  {
    // feed the animal
  }
}

Creo que el último también analiza la herencia (por ejemplo, Dog is Animal == true), que es mejor en la mayoría de los casos.

Depende de lo que estoy haciendo. Si necesito un valor bool (por ejemplo, para determinar si voy a convertir a un int), lo usaré is. Si realmente necesito el tipo por alguna razón (por ejemplo, para pasar a algún otro método) lo usaré GetType().

El último es más limpio, más obvio, y también busca subtipos. Los otros no verifican el polimorfismo.

Se usa para obtener el objeto System.Type para un tipo. Una expresión typeof toma la siguiente forma:

System.Type type = typeof(int);

Example:

    public class ExampleClass
    {
       public int sampleMember;
       public void SampleMethod() {}

       static void Main()
       {
          Type t = typeof(ExampleClass);
          // Alternatively, you could use
          // ExampleClass obj = new ExampleClass();
          // Type t = obj.GetType();

          Console.WriteLine("Methods:");
          System.Reflection.MethodInfo[] methodInfo = t.GetMethods();

          foreach (System.Reflection.MethodInfo mInfo in methodInfo)
             Console.WriteLine(mInfo.ToString());

          Console.WriteLine("Members:");
          System.Reflection.MemberInfo[] memberInfo = t.GetMembers();

          foreach (System.Reflection.MemberInfo mInfo in memberInfo)
             Console.WriteLine(mInfo.ToString());
       }
    }
    /*
     Output:
        Methods:
        Void SampleMethod()
        System.String ToString()
        Boolean Equals(System.Object)
        Int32 GetHashCode()
        System.Type GetType()
        Members:
        Void SampleMethod()
        System.String ToString()
        Boolean Equals(System.Object)
        Int32 GetHashCode()
        System.Type GetType()
        Void .ctor()
        Int32 sampleMember
    */

Esta muestra utiliza el método GetType para determinar el tipo que se utiliza para contener el resultado de un cálculo numérico. Esto depende de los requisitos de almacenamiento del número resultante.

    class GetTypeTest
    {
        static void Main()
        {
            int radius = 3;
            Console.WriteLine("Area = {0}", radius * radius * Math.PI);
            Console.WriteLine("The type is {0}",
                              (radius * radius * Math.PI).GetType()
            );
        }
    }
    /*
    Output:
    Area = 28.2743338823081
    The type is System.Double
    */

if (c is UserControl) c.Enabled = enable;

Puede usar el operador "typeof ()" en C # pero necesita llamar al espacio de nombres usando System.IO; Debe usar la palabra clave "is" si desea verificar un tipo.

Prueba de rendimiento typeof () vs GetType ():

using System;
namespace ConsoleApplication1
    {
    class Program
    {
        enum TestEnum { E1, E2, E3 }
        static void Main(string[] args)
        {
            {
                var start = DateTime.UtcNow;
                for (var i = 0; i < 1000000000; i++)
                    Test1(TestEnum.E2);
                Console.WriteLine(DateTime.UtcNow - start);
            }
            {
                var start = DateTime.UtcNow;
                for (var i = 0; i < 1000000000; i++)
                    Test2(TestEnum.E2);
                Console.WriteLine(DateTime.UtcNow - start);
            }
            Console.ReadLine();
        }
        static Type Test1<T>(T value) => typeof(T);
        static Type Test2(object value) => value.GetType();
    }
}

Resultados en modo de depuración:

00:00:08.4096636
00:00:10.8570657

Resultados en modo de liberación:

00:00:02.3799048
00:00:07.1797128