Cómo comparar tipos

Question

Pregunta rápida: cómo comparar un tipo tipo (juego de palabras no intencionado) con otro tipo en C#? Quiero decir, tengo un Type typeField y quiero saber si es System.String, System.DateTime, etc., pero typeField.Equals(System.String) no funciona.

¿Alguna pista?

Answer 1

Pruebe lo siguiente

typeField == typeof(string) 
typeField == typeof(DateTime) 

El operador typeof en C# le dará un objeto Type para el tipo con nombre. Type instancias son comparables con el operador == por lo que este es un buen método para compararlos.

Nota: Si no recuerdo mal, hay algunos casos en que esto se descompone cuando los tipos implicados son interfaces COM que están integradas en los ensamblajes (a través de NoPIA). No suena como este es el caso aquí.

Answer 2

http://msdn.microsoft.com/en-us/library/system.type.gettype.aspx

Console.WriteLine("typeField is a {0}", typeField.GetType()); 

que le daría algo así como

typeField is a String 

typeField is a DateTime 

o

http://msdn.microsoft.com/en-us/library/58918ffs(v=vs.71).aspx

Answer 3

Puede comparar exactamente el mismo tipo usando:

class A { 
} 
var a = new A(); 
var typeOfa = a.GetType(); 
if (typeOfa == typeof(A)) { 
} 

typeof devuelve el objeto Type de una clase dada.

Pero si tiene un tipo B, que hereda de A, entonces esta comparación es falsa. Y usted está buscando IsAssignableFrom.

class B : A { 
} 
var b = new B(); 
var typeOfb = b.GetType(); 

if (typeOfb == typeof(A)) { // false 
} 

if (typeof(A).IsAssignableFrom(typeOfb)) { // true 
} 

Answer 4

se puede utilizar para que el isoperator. A continuación, puede comprobar si el objeto es tipo específico por escrito:

if (myObject is string) 
{ 
    DoSomething() 
} 

Answer 5

Si la instancia es un Type:

Type typeFiled; 
if (typeField == typeof(string)) 
{ 
    ... 
} 

pero si la instancia es un object y no un Type uso, el usuario as:

object value; 
string text = value as string; 
if (text != null) 
{ 
    // value is a string and you can do your work here 
} 

esto tiene la ventaja de convertir value solo una vez en el tipo especificado.