Tipos que aceptan valores NULL: mejor manera de verificar nulos o cero en c #

Estoy trabajando en un proyecto en el que encuentro que estoy comprobando lo siguiente en muchos, muchos lugares:

if(item.Rate == 0 || item.Rate == null) { }

más como curiosidad que cualquier otra cosa, ¿cuál es la mejor manera de verificar ambos casos?

He agregado un método de ayuda que es:

public static bool nz(object obj)
{
    var parsedInt = 0;
    var parsed = int.TryParse(obj.ToString(), out parsedInt);
    return IsNull(obj) || (parsed && parsedInt == 0);
}

¿Existe una forma mejor?

me gusta if ((item.Rate ?? 0) == 0) { }

Actualización 1:

También puede definir un método de extensión como:

public static bool IsNullOrValue(this double? value, double valueToCheck)
{
    return (value??valueToCheck) == valueToCheck;
}

Y utilícelo así:

if(item.IsNullOrValue(0)){} // pero no obtienes mucho de eso

Usando genéricos:

static bool IsNullOrDefault<T>(T value)
{
    return object.Equals(value, default(T));
}

//...
double d = 0;
IsNullOrDefault(d); // true
MyClass c = null;
IsNullOrDefault(c); // true

Si Tes un tipo de referencia , valuese comparará con null( default(T)), de lo contrario, si Tes a value type, digamos doble, default(t)es 0d, para bool es false, para char es '\0'y así sucesivamente ...

Aunque me gusta bastante la respuesta aceptada, creo que, para completar, esta opción también debería mencionarse:

if (item.Rate.GetValueOrDefault() == 0) { }

Esta solución

• no requiere un método adicional,
• es más rápido que todas las demás opciones, ya que GetValueOrDefault es una operación de lectura de un solo campo ¹ y
• lee más fácil que ((item.Rate ?? 0) == 0)(aunque esto podría ser una cuestión de gustos).

¹ Sin embargo, esto no debería influir en su decisión, ya que es poco probable que este tipo de microoptimización marque una diferencia.

En realidad, esto es solo una expansión de la respuesta aceptada de Freddy Rios que solo usa genéricos.

public static bool IsNullOrDefault<T>(this Nullable<T> value) where T : struct
{
    return default(T).Equals( value.GetValueOrDefault() );
}

public static bool IsValue<T>(this Nullable<T> value, T valueToCheck) where T : struct
{
    return valueToCheck.Equals((value ?? valueToCheck));
}

NOTA: ¡no es necesario que verifiquemos el valor predeterminado (T) para nulo ya que estamos tratando con tipos de valor o estructuras! Esto también significa que podemos asumir con seguridad que T valueToCheck no será nulo; ¿Recuerdas aquí esa T? es la abreviatura Nullable <T>, por lo que al agregar la extensión a Nullable <T> obtenemos el método en int ?, double ?, bool? etc.

Ejemplos:

double? x = null;
x.IsNullOrDefault(); //true

int? y = 3;
y.IsNullOrDefault(); //false

bool? z = false;
z.IsNullOrDefault(); //true

Estoy de acuerdo con usar el ?? operador.

Si está tratando con cadenas, use if (String.IsNullOrEmpty (myStr))

hay una mejor manera?

Bueno, si realmente está buscando una mejor manera, probablemente pueda agregar otra capa de abstracción además de Rate. Bueno, aquí hay algo que se me ocurrió usando Nullable Design Pattern.

usando el sistema;
utilizando System.Collections.Generic;

espacio de nombres NullObjectPatternTest
{
    Programa de clase pública
    {
        public static void Main (cadena [] argumentos)
        {
            var items = nueva lista
                            {
                                nuevo artículo (RateFactory.Create (20)),
                                nuevo elemento (RateFactory.Create (nulo))
                            };

            PrintPricesForItems (artículos);
        }

        PrintPricesForItems vacío estático privado (elementos IEnumerable)
        {
            foreach (var elemento en elementos)
                Console.WriteLine ("Precio del artículo: {0: C}", item.GetPrice ());
        }
    }

    ItemBase de clase abstracta pública
    {
        tarifa pública abstracta Tarifa {get; }
        public int GetPrice ()
        {
            // NO es necesario comprobar si Rate == 0 o Rate == null
            return 1 * Rate.Value;
        }
    }

    Artículo de clase pública: ItemBase
    {
        privado readonly Rate _Rate;
        Tasa de tasa de anulación pública {get {return _Rate; }}
        Artículo público (tarifa de tarifa) {_Rate = tarifa; }
    }

    RateFactory de clase pública sellada
    {
        Crear tasa estática pública (int? rateValue)
        {
            if (! rateValue || rateValue == 0) 
                return new NullRate ();
            return new Rate (rateValue);
        }
    }

    Tarifa de clase pública
    {
        public int Value {obtener; conjunto; }
        public virtual bool HasValue {get {return (Valor> 0); }}
        Public Rate (int valor) {Valor = valor; }
    }

    clase pública NullRate: Rate
    {
        public override bool HasValue {get {return false; }}
        public NullRate (): base (0) {}
    }
}

Su muestra de código fallará. Si obj es nulo, obj.ToString () dará como resultado una excepción de referencia nula. Cortaría el proceso y verificaría un obj nulo al comienzo de su función de ayuda. En cuanto a su pregunta real, ¿cuál es el tipo que está buscando nulo o cero? En String hay una gran función IsNullOrEmpty, me parece que este sería un gran uso de los métodos de extensión para implementar un método IsNullOrZero en el int. tipo.

Editar: Recuerde, el '?' es solo el azúcar del compilador para el tipo INullable, por lo que probablemente podría tomar un INullable como parm y luego compararlo con null (parm == null) y, si no es null, compararlo con cero.

public static bool nz(object obj)
{
    return obj == null || obj.Equals(Activator.CreateInstance(obj.GetType()));
}

class Item{  
 bool IsNullOrZero{ get{return ((this.Rate ?? 0) == 0);}}
}

No olvide, para las cadenas, siempre puede usar:

String.IsNullOrEmpty(str)

En vez de:

str==null || str==""

Un paso más allá de la agradable respuesta de Joshua Shannon . Ahora, con la prevención del boxeo / unboxing :

public static class NullableEx
{
    public static bool IsNullOrDefault<T>(this T? value)
        where T : struct
    {
        return EqualityComparer<T>.Default.Equals(value.GetValueOrDefault(), default(T));
    }
}