C#: alternativa a GenericType == null

Question

Necesito comprobar un objeto genérico para nulo, o predeterminado (T). Pero tengo un problema ... Actualmente lo he hecho así:

if (typeof(T).IsValueType) 
{ 
    if(default(T).Equals(thing)) 
    // Do something 
    else 
    // Do something else 
} 
else 
{ 
    if(thing == null) 
    // Do something 
    else 
    // Do something else 
} 

Pero entonces me acaban de repetir lo mismo ... lo que no me gusta. El problema es el siguiente:

thing == null; 

Aquí ReSharper advierte sobre la posible comparación del tipo de valor con 'nulo'.

thing == default(T); 

Aquí me sale error de compilación: No se puede aplicar el operador '==' a operandos de tipo 'T' y 'T'.

thing.Equals(null|default(T)); 

thing, obviamente, puede ser nulo (es por eso que tengo que comprobar!), Por lo que hará que NullReferenceException.

null|default(T).Equals(thing); 

nulo y predeterminado (T) es muy a menudo nulo, así ...

¿Hay una manera limpia de hacer esto ??

Answer 1

Si el boxeo no es un problema, es posible que utilices:

object.Equals(value, default(T)) 

Answer 2

Lo mejor que se me ocurre en este momento es:

return value == null || value.Equals(default(T)); 

Editar:

Al parecer, hay una object.Equals método estático que no estaba al tanto de:

return object.Equals(value, default(T)); 

Este es mejor.

Answer 3

Un poco de boxeo hará bien el trabajo.

static bool IsNullOrDefault<T>(T value) 
    { 
     return ((object)default(T)) == null ? 
      ((object)value) == null : 
      default(T).Equals(value); 
    } 

Answer 4

con las pruebas:

public class DefaultOrNullChecker<T> { 
    public bool Check(object x) { 
     return object.ReferenceEquals(x, null) || x.Equals(default(T)); 
    } 
} 
[TestFixture] 
public class Tests { 
    [Test] public void when_T_is_reference_type() { 
     Assert.IsFalse(new DefaultOrNullChecker<Exception>().Check(new Exception()));} 
    [Test] public void when_T_is_value_type() { 
     Assert.IsFalse(new DefaultOrNullChecker<int>().Check(123)); } 
    [Test] public void when_T_is_null() { 
     Assert.IsTrue(new DefaultOrNullChecker<Exception>().Check(null));} 
    [Test] public void when_T_is_default_value() { 
     Assert.IsTrue(new DefaultOrNullChecker<int>().Check(0)); } 
} 

Answer 5

usted puede evitar por completo el boxeo señalando que nulabilidad de un tipo puede ser determinado estáticamente

Esto es lo que puede hacer:

1. declarar una estática privada de sólo lectura variable llamada isDefault de tipo Predicate<T> en su clase genérica
2. Añadir un inicializador estático a su clase genérica, donde se verifica T nulabilidad, y establecer isDefault a cualquiera v==null o default(T).Equals(v) dependiendo del resultado
3. uso isDefault(x) en lugar de x==null en el resto de su código

Aquí se muestra un ejemplo:

public class Example<T> { 

    private static readonly Predicate<T> isDefault; 

    static Example() { 
     // Nullability check is a bit ugly, but we do it once per T, 
     // so what the heck... 
     if (typeof(T).IsValueType && 
      (!typeof(T).IsGenericType 
     || typeof(T).GetGenericTypeDefinition() != typeof(Nullable<>) 
     )) { 
      // This is safe because T is not null 
      isDefault = val => default(T).Equals(val); 
     } else { 
      // T is not a value type, so its default is null 
      isDefault = val => val == null; 
     } 
    } 

    public bool Check(T value) { 
     // Now our null-checking is both good-looking and efficient 
     return isDefault(value); 
    } 

} 

Answer 6

La forma correcta de hacer esto es:

return EqualityComparer<T>.Default.Equals(value, default(T)) 

Sin boxeo. Incluso se puede definir un método de extensión de esta manera:

public static void bool IsDefault<T>(this T value) 
{ 
    return EqualityComparer<T>.Default.Equals(value, default(T)); 
} 

.. e invocar así:

return entry.IsDefault(); 

Aunque, personalmente no me importa para los métodos de extensión en T (por ejemplo, este objeto EsNulo()) ya que dificulta la legibilidad a veces.

Answer 7

¿Qué pasa con esto?

if (thing == default(T)) { } 

Si se trata de un tipo de valor, el JIT simplemente eliminará la declaración por completo.

Answer 8

Cuando necesito comprobar si el valor es NULL, utilizo el siguiente método. Normalmente uso esto cuando llamo a métodos que toman cualquier tipo pero no nulos, como el Caché.

public static bool IsNull<T>(this T value) 
{ 
    var type = typeof(T); 

    return (type.IsClass || Nullable.GetUnderlyingType(type) != null) 
     && EqualityComparer<T>.Default.Equals(value, default(T)); 

}