Tipi nullable: modo migliore per verificare null o zero in c #

Sto lavorando a un progetto in cui trovo che sto verificando quanto segue in molti, molti posti:

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

più come curiosità che altro, qual è il modo migliore per verificare entrambi i casi?

Ho aggiunto un metodo di supporto che è:

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

Esiste un modo migliore?

mi piace if ((item.Rate ?? 0) == 0) { }

Aggiornamento 1:

Puoi anche definire un metodo di estensione come:

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

E usalo in questo modo:

if(item.IsNullOrValue(0)){} // ma non ci guadagni molto

Usare i generici:

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 Tè un tipo di riferimento , valueverrà confrontato con null( default(T)), altrimenti, se Tè value type, diciamo double, default(t)è 0d, per bool is false, per char is '\0'e così via ...

Sebbene mi piaccia abbastanza la risposta accettata, penso che, per completezza, dovrebbe essere menzionata anche questa opzione:

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

Questa soluzione

• non richiede un metodo aggiuntivo,
• è più veloce di tutte le altre opzioni, poiché GetValueOrDefault è un'operazione di lettura di un singolo campo ¹ e
• si legge più facilmente di ((item.Rate ?? 0) == 0)(potrebbe essere una questione di gusti, però).

¹ Ciò non dovrebbe influenzare la tua decisione, tuttavia, poiché è improbabile che questo tipo di microottimizzazione faccia la differenza.

Questa è davvero solo un'espansione della risposta accettata di Freddy Rios usando solo i Generics.

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 non abbiamo bisogno di controllare default (T) per null poiché abbiamo a che fare con tipi di valore o strutture! Ciò significa anche che possiamo tranquillamente presumere che T valueToCheck non sarà nullo; Ricordi qui quella T? è una scorciatoia Nullable <T> quindi aggiungendo l'estensione a Nullable <T> otteniamo il metodo in int ?, double ?, bool? eccetera.

Esempi:

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

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

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

Sono d'accordo con l'utilizzo del ?? operatore.

Se hai a che fare con stringhe usa if (String.IsNullOrEmpty (myStr))

Esiste un modo migliore?

Bene, se stai davvero cercando un modo migliore, probabilmente puoi aggiungere un altro livello di astrazione oltre a Rate. Bene, ecco qualcosa che ho appena inventato usando Nullable Design Pattern.

using System;
using System.Collections.Generic;

spazio dei nomi NullObjectPatternTest
{
    programma di classe pubblica
    {
        public static void Main (string [] args)
        {
            elementi var = nuovo elenco
                            {
                                nuovo elemento (RateFactory.Create (20)),
                                nuovo elemento (RateFactory.Create (null))
                            };

            PrintPricesForItems (articoli);
        }

        private static void PrintPricesForItems (IEnumerable items)
        {
            foreach (var item in items)
                Console.WriteLine ("Prezzo articolo: {0: C}", item.GetPrice ());
        }
    }

    classe astratta pubblica ItemBase
    {
        abstract pubblico Rate Rate {get; }
        public int GetPrice ()
        {
            // NON è necessario verificare se Rate == 0 o Rate == null
            return 1 * Rate.Value;
        }
    }

    classe pubblica Item: ItemBase
    {
        privato readonly Rate _Rate;
        public override Rate Rate {get {return _Rate; }}
        Articolo pubblico (Tasso tasso) {_Rate = tasso; }
    }

    classe pubblica sigillata RateFactory
    {
        tasso statico pubblico Crea (int? rateValue)
        {
            if (! rateValue || rateValue == 0) 
                return new NullRate ();
            return new Rate (rateValue);
        }
    }

    tasso di classe pubblica
    {
        public int Valore {get; impostato; }
        bool virtuale pubblico HasValue {get {return (Value> 0); }}
        Tasso pubblico (valore int) {Valore = valore; }
    }

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

L'esempio di codice fallirà. Se obj è null, obj.ToString () risulterà in un'eccezione di riferimento null. Abbreviare il processo e verificare la presenza di un oggetto nullo all'inizio della funzione di supporto. Per quanto riguarda la tua domanda effettiva, qual è il tipo che stai verificando per null o zero? Su String c'è una grande funzione IsNullOrEmpty, mi sembra che questo sarebbe un ottimo uso dei metodi di estensione per implementare un metodo IsNullOrZero sull'int? genere.

Modifica: ricorda, il "?" è solo zucchero del compilatore per il tipo INullable, quindi potresti probabilmente prendere un INullable come parametro e quindi confrontarlo con null (parm == null) e se non null confrontare con 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);}}
}

Non dimenticare, per le stringhe, puoi sempre usare:

String.IsNullOrEmpty(str)

Invece di:

str==null || str==""

Un passo avanti rispetto alla bella risposta di Joshua Shannon . Ora con la prevenzione di boxe / 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));
    }
}