example - Reflexión de C#: ¿Cómo obtener el tipo de Nintible<int>?

params comments c#

Question

Lo que quiero hacer es algo como esto:

switch( myObject.GetType().GetProperty( "id") )
{
    case ??: 
        // when Nullable<Int32>, do this
    case ??:
        // when string, do this
    case ??:
        // when Nullable<bool>, do this

¿Qué ruta bajo object.GetType () tendría el nombre de cadena del tipo de datos que podría comparar usando una declaración de caso? Necesito saber el tipo para poder tener uno de los muchos Convert.ToInt32 (cadena) que establecerá el valor de myObject usando Reflection.

Answer 1

Actualización: Parece que C # 7 admitirá la activación de Type s como el autor de esta pregunta estaba tratando de hacer. Aunque es un poco diferente, así que ten cuidado con las sintaxis de las minas terrestres.

No necesitas un nombre de cadena para compararlo:

if (myObject.GetType().GetProperty("id").PropertyType == typeof(Nullable<Int32>))
    // when Nullable<Int32>, do this
else if (myObject.GetType().GetProperty("id").PropertyType == typeof(string))
    // when string, do this
else if (myObject.GetType().GetProperty("id").PropertyType == typeof(Nullable<bool>))
    // when Nullable<bool>, do this

Answer 2

Como dijo @Cody Gray si las declaraciones serían probablemente la mejor manera

var t = myObject.GetType();

if (t == typeof(Nullable<int>))
{ }
else if (t == typeof(string))
{}
else if (t==typeof(Nullable<bool>))
{}

Answer 3

En .net, las instancias de tipos de valor son solo colecciones de bits, sin información de tipo asociada. Sin embargo, para cada tipo de valor que no sea Nullable<T> , el sistema también genera automáticamente un tipo de clase correspondiente que se deriva de System.ValueType . Existe una conversión de ampliación desde el tipo de valor al tipo de clase generado automáticamente, y una conversión de reducción desde el tipo de clase generado automáticamente al tipo de valor. En el caso de Nullable<T> , no hay un tipo de clase autogenerado correspondiente con conversiones a / del tipo de valor; en cambio, las conversiones de ampliación existen en ambas direcciones entre Nullable<T> y el tipo de clase asociado con T

Por lo que puedo decir, este extraño comportamiento se implementó para permitir que las comparaciones entre null y un Nullable<T> vacío Nullable<T> devuelvan verdadero.

Answer 4

He estado usando el siguiente tipo de código para verificar si el tipo es anulable y para obtener el tipo real:

if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
{
    return Nullable.GetUnderlyingType(type);
}

Si el tipo es, por ejemplo, anulable, este código devuelve la parte int (tipo subyacente). Si solo necesita convertir un objeto en un tipo específico, puede usar el método System.Convert.ChangeType .

Answer 5

La pregunta es muy confusa. ¿Es "myObject" el objeto que podría ser un int. ¿O es la propiedad "id" posiblemente de tipo nullable int?

Si es lo primero, tu pregunta no puede ser contestada porque presupone una falsedad. No hay tal cosa como un int. Observo que todas las respuestas que proponen if (myobject.GetType() == typeof(int?)) Son, por lo tanto, incorrectas; La condición nunca será cierta.

Cuando convierte un int nulable en objeto, o bien se convierte en una referencia nula (si el int nulable no tiene valor) o se convierte en un int recuadrado. No hay forma de determinar si un objeto contiene un int anulable porque un objeto nunca contiene un int anulable.

Si es este último, compare el tipo de propiedad con typeof(int?) . No puedes usar un interruptor; solo se pueden usar constantes para los casos de cambio y los tipos no son constantes.

Todo lo dicho, este es un mal olor de código. ¿Por qué usas la reflexión en primer lugar?