Comprobando si el objeto es del mismo tipo

Question

Hola Necesito saber cómo comprobar si el objeto del mismo tipo en C#.

Escenario:

class Base_Data{} 

class Person : Base_Data {} 
class Phone : Base_data {} 

class AnotherClass{ 

    public void CheckObject(Base_Data data){ 
     if(data.Equals(Person.GetType())){ //<-- Visual Studio 2010 gives me error, says that I am using 'Person' is a type and not a variable. 

     } 
    } 
} 

Answer 1

podría utilizar el is operador:

if (data is Person) 
{ 
    // data is an instance of Person 
} 

Otra posibilidad es utilizar el as operador:

Person person = data as Person; 
if (person != null) 
{ 
    // safely use person here 
} 

Answer 2

Depende exactamente lo que Está después. El uso de is o as (como se muestra en la respuesta de Darin) le dirá si data se refiere a una instancia de Persono un subtipo. Esa es la forma más común (aunque si puede diseñar lejos de necesitarla, sería aún mejor) - y si eso es lo que necesita, la respuesta de Darin es el enfoque a seguir.

Sin embargo, si necesita una exacta partido - si no desea tomar la acción particular si data se refiere a una instancia de alguna clase derivada de Person, sólo para Person sí, necesitará algo así como esto:

if (data.GetType() == typeof(Person)) 

Esto es relativamente raro, y definitivamente vale la pena cuestionar su diseño en este momento.

Answer 3

Arreglemos esto un paso a la vez. El primer paso es obligatorio, los siguientes dos son opcionales pero sugeridos.

La primera corrección (que se requiere) se asegura de que no se está comparando un objeto de algún tipo con un objeto de tipo System.Type:

if (data.GetType().Equals(typeof(Person))) ... 
//  ^^^^^^^^^^ 
//  add this to make sure you're comparing Type against Type, not 
//  Base_Data against Type (which caused the type-check error)! 

En segundo lugar, simplificar este a:

if (data is Person) ... // this has (almost) the same meaning as the above; 
         // in your case, it's what you need. 

En tercer lugar, deshacerse de la if comunicado conjunto! Esto se hace empleando polimorfismo (o, más precisamente, anulación de método), p. de la siguiente manera:

class Base_Data 
{ 
    public virtual void Check() { ... } 
} 

class Person : Base_Data 
{ 
    public override void Check() 
    { 
     ... // <-- do whatever you would have done inside the if block 
    } 
} 

class AnotherClass 
{ 
    public void CheckData(Base_Data data) 
    { 
     data.Check(); 
    } 
} 

Como se ve, el código condicional se ha desplazado en un método de la clase Base_DataCheck y su clase derivada Person. No más necesidad de tal declaración de verificación de tipo if!