¿Cómo verificar si un objeto es anulable?

¿Cómo puedo verificar si un objeto dado es anulable? En otras palabras, cómo implementar el siguiente método ...

bool IsNullableValueType(object o)
{
    ...
}

EDITAR: Estoy buscando tipos de valores anulables. No tenía tipos de referencia en mente.

//Note: This is just a sample. The code has been simplified 
//to fit in a post.

public class BoolContainer
{
    bool? myBool = true;
}

var bc = new BoolContainer();

const BindingFlags bindingFlags = BindingFlags.Public
                        | BindingFlags.NonPublic
                        | BindingFlags.Instance
                        ;


object obj;
object o = (object)bc;

foreach (var fieldInfo in o.GetType().GetFields(bindingFlags))
{
    obj = (object)fieldInfo.GetValue(o);
}

obj ahora se refiere a un objeto de tipo bool( System.Boolean) con un valor igual a true. Lo que realmente quería era un objeto de tipoNullable<bool>

Así que ahora, como alternativa, decidí verificar si o es anulable y crear un contenedor anulable alrededor de obj.

Hay dos tipos de anulables, Nullable<T>y de tipo de referencia.

Jon me ha corregido que es difícil obtener el tipo de letra si está en caja, pero puede hacerlo con los genéricos: - ¿qué tal a continuación? Esto es en realidad una prueba de tipo T, pero usando el objparámetro solo para inferencia de tipo genérico (para que sea más fácil llamar), sin embargo, funcionaría casi de manera idéntica sin el objparámetro.

static bool IsNullable<T>(T obj)
{
    if (obj == null) return true; // obvious
    Type type = typeof(T);
    if (!type.IsValueType) return true; // ref-type
    if (Nullable.GetUnderlyingType(type) != null) return true; // Nullable<T>
    return false; // value-type
}

Pero esto no funcionará tan bien si ya ha encuadrado el valor en una variable de objeto.

Documentación de Microsoft: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/nullable-types/how-to-identify-a-nullable-type

Existe una solución muy simple que utiliza sobrecargas de métodos.

http://deanchalk.com/is-it-nullable/

extracto:

public static class ValueTypeHelper
{
    public static bool IsNullable<T>(T t) { return false; }
    public static bool IsNullable<T>(T? t) where T : struct { return true; }
}

luego

static void Main(string[] args)
{
    int a = 123;
    int? b = null;
    object c = new object();
    object d = null;
    int? e = 456;
    var f = (int?)789;
    bool result1 = ValueTypeHelper.IsNullable(a); // false
    bool result2 = ValueTypeHelper.IsNullable(b); // true
    bool result3 = ValueTypeHelper.IsNullable(c); // false
    bool result4 = ValueTypeHelper.IsNullable(d); // false
    bool result5 = ValueTypeHelper.IsNullable(e); // true
    bool result6 = ValueTypeHelper.IsNullable(f); // true

La pregunta "¿Cómo verificar si un tipo es anulable?" en realidad es "¿Cómo verificar si un tipo es Nullable<>?", que se puede generalizar a "¿Cómo verificar si un tipo es un tipo construido de algún tipo genérico?", de modo que no solo responda la pregunta "¿Es Nullable<int>un Nullable<>?", pero también "¿Es List<int>un List<>?".

La mayoría de las soluciones proporcionadas utilizan el Nullable.GetUnderlyingType()método, que obviamente solo funcionará con el caso de Nullable<>. No vi la solución reflexiva general que funcionaría con cualquier tipo genérico, por lo que decidí agregarla aquí para la posteridad, a pesar de que esta pregunta ya ha sido respondida hace mucho tiempo.

Para comprobar si un tipo es una forma de Nullable<>utilizar la reflexión, primero hay que convertir su tipo genérico construido, por ejemplo Nullable<int>, en la definición de tipo genérico, Nullable<>. Puede hacerlo utilizando el GetGenericTypeDefinition()método de la Typeclase. Luego puede comparar el tipo resultante con Nullable<>:

Type typeToTest = typeof(Nullable<int>);
bool isNullable = typeToTest.GetGenericTypeDefinition() == typeof(Nullable<>);
// isNullable == true

Lo mismo se puede aplicar a cualquier tipo genérico:

Type typeToTest = typeof(List<int>);
bool isList = typeToTest.GetGenericTypeDefinition() == typeof(List<>);
// isList == true

Varios tipos pueden parecer lo mismo, pero un número diferente de argumentos de tipo significa que es un tipo completamente diferente.

Type typeToTest = typeof(Action<DateTime, float>);
bool isAction1 = typeToTest.GetGenericTypeDefinition() == typeof(Action<>);
bool isAction2 = typeToTest.GetGenericTypeDefinition() == typeof(Action<,>);
bool isAction3 = typeToTest.GetGenericTypeDefinition() == typeof(Action<,,>);
// isAction1 == false
// isAction2 == true
// isAction3 == false

Dado que los Typeobjetos se instancian una vez por tipo, puede verificar la igualdad de referencia entre ellos. Entonces, si desea verificar si dos objetos son de la misma definición de tipo genérico, puede escribir:

var listOfInts = new List<int>();
var listOfStrings = new List<string>();

bool areSameGenericType =
    listOfInts.GetType().GetGenericTypeDefinition() ==
    listOfStrings.GetType().GetGenericTypeDefinition();
// areSameGenericType == true

Si desea verificar si un objeto es anulable, en lugar de un Type, entonces puede usar la técnica anterior junto con la solución de Marc Gravell para crear un método bastante simple:

static bool IsNullable<T>(T obj)
{
    if (!typeof(T).IsGenericType)
        return false;

    return typeof(T).GetGenericTypeDefinition() == typeof(Nullable<>);
}

Esto funciona para mí y parece simple:

static bool IsNullable<T>(T obj)
{
    return default(T) == null;
}

Para tipos de valor:

static bool IsNullableValueType<T>(T obj)
{
    return default(T) == null && typeof(T).BaseType != null && "ValueType".Equals(typeof(T).BaseType.Name);
}

Bueno, podrías usar:

return !(o is ValueType);

... pero un objeto en sí no es anulable o no, un tipo sí lo es. ¿Cómo planeabas usar esto?

La forma más simple que puedo entender es:

public bool IsNullable(object obj)
{
    Type t = obj.GetType();
    return t.IsGenericType 
        && t.GetGenericTypeDefinition() == typeof(Nullable<>);
}

Aquí hay dos problemas: 1) probar para ver si un Tipo es anulable; y 2) pruebas para ver si un objeto representa un tipo que admite valores NULL.

Para el problema 1 (probar un tipo), aquí hay una solución que he usado en mis propios sistemas: solución TypeIsNullable-check

Para el problema 2 (probar un objeto), la solución anterior de Dean Chalk funciona para los tipos de valor, pero no funciona para los tipos de referencia, ya que el uso de la sobrecarga <T> siempre devuelve falso. Dado que los tipos de referencia son inherentemente anulables, probar un tipo de referencia siempre debe devolver verdadero. Consulte la nota [Acerca de "nulabilidad"] a continuación para obtener una explicación de estas semánticas. Por lo tanto, aquí está mi modificación al enfoque de Dean:

    public static bool IsObjectNullable<T>(T obj)
    {
        // If the parameter-Type is a reference type, or if the parameter is null, then the object is always nullable
        if (!typeof(T).IsValueType || obj == null)
            return true;

        // Since the object passed is a ValueType, and it is not null, it cannot be a nullable object
        return false; 
    }

    public static bool IsObjectNullable<T>(T? obj) where T : struct
    {
        // Always return true, since the object-type passed is guaranteed by the compiler to always be nullable
        return true;
    }

Y aquí está mi modificación al código de prueba del cliente para la solución anterior:

    int a = 123;
    int? b = null;
    object c = new object();
    object d = null;
    int? e = 456;
    var f = (int?)789;
    string g = "something";

    bool isnullable = IsObjectNullable(a); // false 
    isnullable = IsObjectNullable(b); // true 
    isnullable = IsObjectNullable(c); // true 
    isnullable = IsObjectNullable(d); // true 
    isnullable = IsObjectNullable(e); // true 
    isnullable = IsObjectNullable(f); // true 
    isnullable = IsObjectNullable(g); // true

La razón por la que modifiqué el enfoque de Dean en IsObjectNullable <T> (T t) es que su enfoque original siempre devolvió falso para un tipo de referencia. Dado que un método como IsObjectNullable debería ser capaz de manejar valores de tipo de referencia y dado que todos los tipos de referencia son inherentemente anulables, entonces si se pasa un tipo de referencia o un valor nulo, el método siempre debe devolver verdadero.

Los dos métodos anteriores podrían reemplazarse con el siguiente método único y lograr el mismo resultado:

    public static bool IsObjectNullable<T>(T obj)
    {
        Type argType = typeof(T);
        if (!argType.IsValueType || obj == null)
            return true;
        return argType.IsGenericType && argType.GetGenericTypeDefinition() == typeof(Nullable<>);
    }

Sin embargo, el problema con este último enfoque de método único es que el rendimiento sufre cuando se usa un parámetro Nullable <T>. Se necesita mucho más tiempo de procesador para ejecutar la última línea de este método único que para permitir que el compilador elija la segunda sobrecarga del método que se muestra anteriormente cuando se usa un parámetro de tipo Nullable <T> en la llamada IsObjectNullable. Por lo tanto, la solución óptima es utilizar el enfoque de dos métodos ilustrado aquí.

PRUEBA: Este método funciona de manera confiable solo si se llama usando la referencia de objeto original o una copia exacta, como se muestra en los ejemplos. Sin embargo, si un objeto anulable se encuadra en otro Tipo (como un objeto, etc.) en lugar de permanecer en su forma original Anulable <>, este método no funcionará de manera confiable. Si el código que llama a este método no utiliza la referencia de objeto original sin caja o una copia exacta, no puede determinar de manera confiable la nulabilidad del objeto utilizando este método.

En la mayoría de los escenarios de codificación, para determinar la nulabilidad, uno debe confiar en probar el Tipo del objeto original, no su referencia (por ejemplo, el código debe tener acceso al Tipo original del objeto para determinar la nulabilidad). En estos casos más comunes, IsTypeNullable (ver enlace) es un método confiable para determinar la nulabilidad.

PD: sobre "nulabilidad"

Debo repetir una declaración sobre la nulabilidad que hice en una publicación separada, que se aplica directamente a abordar este tema correctamente. Es decir, creo que el foco de la discusión aquí no debería ser cómo verificar si un objeto es un tipo Nullable genérico, sino más bien si se puede asignar un valor nulo a un objeto de su tipo. En otras palabras, creo que deberíamos determinar si un tipo de objeto es anulable, no si es anulable. La diferencia está en la semántica, es decir, las razones prácticas para determinar la nulabilidad, que generalmente es lo único que importa.

En un sistema que utiliza objetos con tipos posiblemente desconocidos hasta el tiempo de ejecución (servicios web, llamadas remotas, bases de datos, feeds, etc.), un requisito común es determinar si se puede asignar un valor nulo al objeto o si el objeto puede contener un nulo Realizar tales operaciones en tipos no anulables probablemente producirá errores, generalmente excepciones, que son muy costosos tanto en términos de rendimiento como de requisitos de codificación. Para adoptar el enfoque altamente preferido de evitar proactivamente tales problemas, es necesario determinar si un objeto de un Tipo arbitrario es capaz de contener un valor nulo; es decir, si es generalmente 'anulable'.

En un sentido muy práctico y típico, la nulabilidad en términos .NET no implica necesariamente que el Tipo de un objeto sea una forma de Nullable. De hecho, en muchos casos, los objetos tienen tipos de referencia, pueden contener un valor nulo y, por lo tanto, son anulables; ninguno de estos tiene un tipo Nullable. Por lo tanto, para fines prácticos en la mayoría de los escenarios, las pruebas deben realizarse para el concepto general de nulabilidad, en comparación con el concepto de Nullable dependiente de la implementación. Por lo tanto, no debemos colgarnos enfocándonos únicamente en el tipo .NET Nullable, sino más bien incorporar nuestra comprensión de sus requisitos y comportamiento en el proceso de enfocarnos en el concepto general y práctico de nulabilidad.

La solución más simple que se me ocurrió es implementar la solución de Microsoft ( Cómo: identificar un tipo anulable (Guía de programación de C #) ) como método de extensión:

public static bool IsNullable(this Type type)
{
    return Nullable.GetUnderlyingType(type) != null;
}

Esto se puede llamar así:

bool isNullable = typeof(int).IsNullable();

Esto también parece una forma lógica de acceso IsNullable()porque encaja con todos los otros IsXxxx()métodos de la Typeclase.

Tenga cuidado, al boxear un tipo anulable ( Nullable<int>o int? Por ejemplo):

int? nullValue = null;
object boxedNullValue = (object)nullValue;
Debug.Assert(boxedNullValue == null);

int? value = 10;
object boxedValue = (object)value;
Debug.Assert( boxedValue.GetType() == typeof(int))

Se convierte en un verdadero tipo de referencia, por lo que pierde el hecho de que era anulable.

Tal vez un poco fuera de tema, pero aún así alguna información interesante. Encuentro a muchas personas que utilizan Nullable.GetUnderlyingType() != nullpara identificar si un tipo es anulable. Obviamente, esto funciona, pero Microsoft aconseja lo siguiente type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)(consulte http://msdn.microsoft.com/en-us/library/ms366789.aspx ).

Miré esto desde el punto de vista del rendimiento. La conclusión de la prueba (un millón de intentos) a continuación es que cuando un tipo es anulable, la opción de Microsoft ofrece el mejor rendimiento.

Nullable.GetUnderlyingType (): 1335ms (3 veces más lento)

GetGenericTypeDefinition () == typeof (Nullable <>): 500ms

Sé que estamos hablando de una pequeña cantidad de tiempo, pero a todos les encanta ajustar los milisegundos :-)! Entonces, si su jefe quiere que reduzca algunos milisegundos, entonces este es su salvador ...

/// <summary>Method for testing the performance of several options to determine if a type is     nullable</summary>
[TestMethod]
public void IdentityNullablePerformanceTest()
{
    int attempts = 1000000;

    Type nullableType = typeof(Nullable<int>);

    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();
    for (int attemptIndex = 0; attemptIndex < attempts; attemptIndex++)
    {
        Assert.IsTrue(Nullable.GetUnderlyingType(nullableType) != null, "Expected to be a nullable"); 
    }

    Console.WriteLine("Nullable.GetUnderlyingType(): {0} ms", stopwatch.ElapsedMilliseconds);

    stopwatch.Restart();

    for (int attemptIndex = 0; attemptIndex < attempts; attemptIndex++)
   {
       Assert.IsTrue(nullableType.IsGenericType && nullableType.GetGenericTypeDefinition() == typeof(Nullable<>), "Expected to be a nullable");
   }

   Console.WriteLine("GetGenericTypeDefinition() == typeof(Nullable<>): {0} ms", stopwatch.ElapsedMilliseconds);
   stopwatch.Stop();
}

Esta versión:

• el almacenamiento en caché de resultados es más rápido,
• no requiere variables innecesarias, como Método (T obj)
• NO COMPLICADO :),
• solo clase genérica estática, que tiene campos calculados una sola vez

:

public static class IsNullable<T>
{
    private static readonly Type type = typeof(T);
    private static readonly bool is_nullable = type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
    public static bool Result { get { return is_nullable; } }
}

bool is_nullable = IsNullable<int?>.Result;

Esto es lo que se me ocurrió, ya que todo lo demás parecía fallar, al menos en el PLC - Biblioteca de clases portátil / .NET Core con> = C # 6

Solución: amplíe los métodos estáticos para cualquier tipo Ty Nullable<T>utilice el hecho de que el método de extensión estática, que coincide con el tipo subyacente, se invocará y prevalecerá sobre el Tmétodo de extensión genérico .

Para T:

public static partial class ObjectExtension
{
    public static bool IsNullable<T>(this T self)
    {
        return false;
    }
}

y para Nullable<T>

public static partial class NullableExtension
{
    public static bool IsNullable<T>(this Nullable<T> self) where T : struct
    {
        return true;
    }
}

Usar Reflection y type.IsGenericType... no funcionó en mi conjunto actual de .NET Runtimes. Tampoco ayudó la documentación de MSDN .

if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)) {…}

En parte porque la API de Reflection ha cambiado bastante significativamente en .NET Core.

Creo que los que usan las pruebas sugeridas de Microsoft IsGenericTypeson buenos, pero en el código para GetUnderlyingType, Microsoft usa una prueba adicional para asegurarse de que no pasó la definición de tipo genérico Nullable<>:

 public static bool IsNullableType(this Type nullableType) =>
    // instantiated generic type only                
    nullableType.IsGenericType &&
    !nullableType.IsGenericTypeDefinition &&
    Object.ReferenceEquals(nullableType.GetGenericTypeDefinition(), typeof(Nullable<>));

Una forma simple de hacer esto:

    public static bool IsNullable(this Type type)
    {
        if (type.IsValueType) return Activator.CreateInstance(type) == null;

        return true;
    }

estas son mis pruebas unitarias y todas pasaron

    IsNullable_String_ShouldReturn_True
    IsNullable_Boolean_ShouldReturn_False
    IsNullable_Enum_ShouldReturn_Fasle
    IsNullable_Nullable_ShouldReturn_True
    IsNullable_Class_ShouldReturn_True
    IsNullable_Decimal_ShouldReturn_False
    IsNullable_Byte_ShouldReturn_False
    IsNullable_KeyValuePair_ShouldReturn_False

pruebas unitarias reales

    [TestMethod]
    public void IsNullable_String_ShouldReturn_True()
    {
        var typ = typeof(string);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Boolean_ShouldReturn_False()
    {
        var typ = typeof(bool);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Enum_ShouldReturn_Fasle()
    {
        var typ = typeof(System.GenericUriParserOptions);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Nullable_ShouldReturn_True()
    {
        var typ = typeof(Nullable<bool>);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Class_ShouldReturn_True()
    {
        var typ = typeof(TestPerson);
        var result = typ.IsNullable();
        Assert.IsTrue(result);
    }

    [TestMethod]
    public void IsNullable_Decimal_ShouldReturn_False()
    {
        var typ = typeof(decimal);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_Byte_ShouldReturn_False()
    {
        var typ = typeof(byte);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }

    [TestMethod]
    public void IsNullable_KeyValuePair_ShouldReturn_False()
    {
        var typ = typeof(KeyValuePair<string, string>);
        var result = typ.IsNullable();
        Assert.IsFalse(result);
    }