Tipos anuláveis: melhor maneira de verificar se há nulo ou zero em c #

Estou trabalhando em um projeto em que estou verificando o seguinte em muitos, muitos lugares:

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

mais como uma curiosidade do que qualquer outra coisa, qual é a melhor maneira de verificar os dois casos?

Eu adicionei um método auxiliar que é:

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

Existe uma maneira melhor?

Eu gosto if ((item.Rate ?? 0) == 0) { }

Atualização 1:

Você também pode definir um método de extensão como:

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

E use-o assim:

if(item.IsNullOrValue(0)){} // mas você não consegue muito com isso

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

Se Tfor um tipo de referência , valueserá comparado com null( default(T)), caso contrário, se Tfor a value type, digamos double, default(t)é 0d, para bool is false, for char is '\0'e assim por diante ...

Embora eu goste bastante da resposta aceita, acho que, para ser mais completo, essa opção também deve ser mencionada:

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

Esta solução

• não requer um método adicional,
• é mais rápido do que todas as outras opções, uma vez que GetValueOrDefault é uma operação de leitura de campo único ¹ e
• lê mais fácil do que ((item.Rate ?? 0) == 0)(pode ser uma questão de gosto, no entanto).

¹ Isso não deve influenciar sua decisão, pois esses tipos de microotimização provavelmente não farão qualquer diferença.

Esta é realmente apenas uma expansão da resposta aceita de Freddy Rios usando apenas 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 , não precisamos verificar default (T) para null, pois estamos lidando com tipos de valor ou estruturas! Isso também significa que podemos assumir com segurança que T valueToCheck não será nulo; Lembra aqui daquele T? é uma abreviação Nullable <T>, portanto, adicionando a extensão a Nullable <T> obtemos o método em int ?, double ?, bool? etc.

Exemplos:

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

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

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

Eu concordo em usar o ?? operador.

Se você estiver lidando com strings, use if (String.IsNullOrEmpty (myStr))

Existe uma maneira melhor?

Bem, se você realmente está procurando uma maneira melhor, provavelmente pode adicionar outra camada de abstração em cima de Taxa. Bem, aqui está algo que acabei de criar usando o padrão de design anulável.

using System;
using System.Collections.Generic;

namespace NullObjectPatternTest
{
    Programa de classe pública
    {
        public static void Main (string [] args)
        {
            var items = nova lista
                            {
                                novo item (RateFactory.Create (20)),
                                novo item (RateFactory.Create (null))
                            };

            PrintPricesForItems (itens);
        }

        private static void PrintPricesForItems (IEnumerable items)
        {
            foreach (item var em itens)
                Console.WriteLine ("Preço do item: {0: C}", item.GetPrice ());
        }
    }

    public abstract class ItemBase
    {
        public abstract Rate Rate {get; }
        public int GetPrice ()
        {
            // NÃO há necessidade de verificar se Rate == 0 ou Rate == null
            return 1 * Rate.Value;
        }
    }

    public class Item: ItemBase
    {
        private readonly Rate _Rate;
        public override Rate Rate {get {return _Rate; }}
        Item público (taxa de taxa) {_Rate = taxa; }
    }

    classe pública selada RateFactory
    {
        public static Rate Create (int? rateValue)
        {
            if (! rateValue || rateValue == 0) 
                retornar novo NullRate ();
            retornar uma nova taxa (rateValue);
        }
    }

    taxa de classe pública
    {
        public int Value {get; conjunto; }
        public virtual bool HasValue {get {return (Value> 0); }}
        Taxa pública (valor interno) {Valor = valor; }
    }

    public class NullRate: Taxa
    {
        public override bool HasValue {get {return false; }}
        public NullRate (): base (0) {}
    }
}

Sua amostra de código falhará. Se obj for nulo, o obj.ToString () resultará em uma exceção de referência nula. Eu encurtaria o processo e verificaria se há um obj nulo no início da função auxiliar. Quanto à sua pergunta real, qual é o tipo que você está verificando para nulo ou zero? Em String há uma ótima função IsNullOrEmpty, parece-me que isso seria um ótimo uso de métodos de extensão para implementar um método IsNullOrZero no int? tipo.

Edit: Lembre-se, o '?' é apenas o açúcar do compilador para o tipo INullable, então você provavelmente poderia pegar um INullable como o parm e então compará-lo com null (parm == null) e se não for null comparar com zero.

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);}}
}

Não se esqueça, para strings, você sempre pode usar:

String.IsNullOrEmpty(str)

Ao invés de:

str==null || str==""

Um passo adiante da boa resposta de Joshua Shannon . Agora com a prevenção de boxing / 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));
    }
}