Typy dopuszczające wartość null: lepszy sposób sprawdzania wartości null lub zera w języku C #

Pracuję nad projektem, w którym w wielu, wielu miejscach sprawdzam następujące kwestie:

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

bardziej jako ciekawostka niż cokolwiek innego, jak najlepiej sprawdzić oba przypadki?

Dodałem metodę pomocniczą, która jest:

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

Czy jest lepszy sposób?

podoba mi się if ((item.Rate ?? 0) == 0) { }

Aktualizacja 1:

Możesz także zdefiniować metodę rozszerzenia, taką jak:

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

I użyj tego w ten sposób:

if(item.IsNullOrValue(0)){} // ale niewiele z tego czerpiesz

Korzystanie z typów ogólnych:

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

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

Jeśli Tjest to typ referencyjny , valuezostanie porównany z null( default(T)), w przeciwnym razie, jeśli Tto value type, powiedzmy double, default(t)to 0d, dla bool is false, for char is '\0'i tak dalej ...

Chociaż podoba mi się przyjęta odpowiedź, myślę, że dla kompletności tę opcję należy również wspomnieć:

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

To rozwiązanie

• nie wymaga dodatkowej metody,
• jest szybszy niż wszystkie inne opcje, ponieważ GetValueOrDefault to operacja odczytu pojedynczego pola ¹ i
• czyta łatwiej niż ((item.Rate ?? 0) == 0)(choć może to być kwestia gustu).

¹ Nie powinno to jednak wpłynąć na Twoją decyzję, ponieważ jest mało prawdopodobne, aby tego rodzaju mikro-optymalizacja miała jakiekolwiek znaczenie.

To naprawdę tylko rozwinięcie zaakceptowanej odpowiedzi Freddy'ego Riosa tylko przy użyciu 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));
}

UWAGA nie musimy sprawdzać wartości default (T) dla null, ponieważ mamy do czynienia z typami wartości lub strukturami! Oznacza to również, że możemy bezpiecznie założyć, że wartość T valueToCheck nie będzie zerowa; Pamiętasz tutaj, że T? jest skrótem Nullable <T>, więc dodając rozszerzenie do Nullable <T> otrzymujemy metodę w int ?, double ?, bool? itp.

Przykłady:

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

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

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

Zgadzam się z użyciem ?? operator.

Jeśli masz do czynienia z ciągami znaków, użyj if (String.IsNullOrEmpty (myStr))

czy jest lepszy sposób?

Cóż, jeśli naprawdę szukasz lepszego sposobu, prawdopodobnie możesz dodać kolejną warstwę abstrakcji do Rate. Oto coś, co właśnie wymyśliłem, używając wzorca projektowego Nullable.

using System;
using System.Collections.Generic;

przestrzeń nazw NullObjectPatternTest
{
    Program zajęć publicznych
    {
        public static void Main (string [] args)
        {
            var items = nowa lista
                            {
                                nowy element (RateFactory.Create (20)),
                                nowy przedmiot (RateFactory.Create (null))
                            };

            PrintPricesForItems (elementy);
        }

        private static void PrintPricesForItems (IEnumerable items)
        {
            foreach (zmienna pozycja w pozycjach)
                Console.WriteLine ("Cena pozycji: {0: C}", item.GetPrice ());
        }
    }

    publiczna klasa abstrakcyjna ItemBase
    {
        public abstract Rate Rate {get; }
        public int GetPrice ()
        {
            // NIE ma potrzeby sprawdzania, czy Rate == 0 lub Rate == null
            zwrot 1 * Rate.Value;
        }
    }

    klasa publiczna Item: ItemBase
    {
        prywatny tylko do odczytu Rate _Rate;
        public override Rate Rate {get {return _Rate; }}
        pozycja publiczna (stawka stawki) {_Rate = stopa; }
    }

    publicznie zapieczętowana klasa RateFactory
    {
        publiczne tworzenie stawki statycznej (int? rateValue)
        {
            if (! rateValue || rateValue == 0) 
                return new NullRate ();
            return new Rate (rateValue);
        }
    }

    klasa publiczna Kurs
    {
        public int Value {get; zestaw; }
        publiczne wirtualne bool HasValue {get {return (Value> 0); }}
        public Stawka (wartość int) {Wartość = wartość; }
    }

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

Twój przykładowy kod nie powiedzie się. Jeśli obj ma wartość null, wówczas obj.ToString () spowoduje wyjątek odwołania o wartości null. Skróciłbym proces i sprawdziłbym, czy na początku twojej funkcji pomocniczej nie ma null obj. A jeśli chodzi o twoje aktualne pytanie, jakiego typu sprawdzasz pod kątem wartości null lub zero? W String jest świetna funkcja IsNullOrEmpty, wydaje mi się, że byłoby to świetne użycie metod rozszerzających do zaimplementowania metody IsNullOrZero w int? rodzaj.

Edycja: pamiętaj, „?” jest tylko cukrem kompilatora dla typu INullable, więc prawdopodobnie możesz wziąć INullable jako parametr, a następnie porównać go z wartością null (parm == null), a jeśli nie, to porównać do zera.

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

Nie zapominaj, że w przypadku stringów zawsze możesz użyć:

String.IsNullOrEmpty(str)

Zamiast:

str==null || str==""

O krok dalej od miłej odpowiedzi Joshuy Shannona . Teraz z zapobieganiem boksowaniu / rozpakowywaniu :

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