Nullable-Typen: Bessere Möglichkeit, in c # nach Null oder Null zu suchen

Ich arbeite an einem Projekt, bei dem ich an vielen, vielen Orten nach Folgendem suche:

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

Was ist der beste Weg, um beide Fälle zu überprüfen?

Ich habe eine Hilfsmethode hinzugefügt, die lautet:

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

Gibt es einen besseren Weg?

ich mag if ((item.Rate ?? 0) == 0) { }

Update 1:

Sie können auch eine Erweiterungsmethode definieren wie:

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

Und benutze es so:

if(item.IsNullOrValue(0)){} // aber du bekommst nicht viel davon

Generika verwenden:

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

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

Wenn Tes eine ist Referenztyp , valuewird im Vergleich zu null( default(T)), andernfalls, wenn Teine ist value type, sagen wir mal doppelt, default(t)ist 0T, für Bool ist false, für char ist '\0'und so weiter ...

Obwohl mir die akzeptierte Antwort sehr gefällt, denke ich, dass der Vollständigkeit halber auch diese Option erwähnt werden sollte:

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

Diese Lösung

• erfordert keine zusätzliche Methode,
• ist schneller als alle anderen Optionen, da GetValueOrDefault eine einzelne Feldleseoperation ¹ und ist
• liest sich einfacher als ((item.Rate ?? 0) == 0)(dies könnte jedoch Geschmackssache sein).

¹ Dies sollte jedoch keinen Einfluss auf Ihre Entscheidung haben, da diese Art der Mikrooptimierung wahrscheinlich keinen Unterschied macht.

Dies ist wirklich nur eine Erweiterung der von Freddy Rios akzeptierten Antwort, die nur Generika verwendet.

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

HINWEIS Wir müssen Standard (T) nicht auf Null prüfen, da es sich entweder um Werttypen oder Strukturen handelt! Dies bedeutet auch, dass wir davon ausgehen können, dass T valueToCheck nicht null ist. Erinnerst du dich hier an das T? ist die Kurzform Nullable <T>. Wenn Sie also die Erweiterung zu Nullable <T> hinzufügen, erhalten Sie die Methode in int?, double?, bool? etc.

Beispiele:

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

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

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

Ich bin mit der Verwendung der ?? Operator.

Wenn Sie mit Strings arbeiten, verwenden Sie if (String.IsNullOrEmpty (myStr))

Gibt es einen besseren Weg?

Wenn Sie wirklich nach einem besseren Weg suchen, können Sie wahrscheinlich zusätzlich zu Rate eine weitere Abstraktionsebene hinzufügen. Nun, hier ist etwas, das ich mir gerade mit Nullable Design Pattern ausgedacht habe.

using System;
using System.Collections.Generic;

Namespace NullObjectPatternTest
{
    öffentliches Klassenprogramm
    {
        public static void Main (string [] args)
        {
            var items = neue Liste
                            {
                                neues Element (RateFactory.Create (20)),
                                neues Element (RateFactory.Create (null))
                            };

            PrintPricesForItems (Elemente);
        }}

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

    öffentliche abstrakte Klasse ItemBase
    {
        public abstract Rate Rate {get; }}
        public int GetPrice ()
        {
            // Es muss NICHT geprüft werden, ob Rate == 0 oder Rate == null ist
            return 1 * Rate.Value;
        }}
    }}

    öffentliche Klasse Item: ItemBase
    {
        privat schreibgeschützt Rate _Rate;
        public override Rate Rate {get {return _Rate; }}
        öffentlicher Gegenstand (Rate Rate) {_Rate = Rate; }}
    }}

    öffentliche versiegelte Klasse RateFactory
    {
        public static Rate Create (int? rateValue)
        {
            if (! rateValue || rateValue == 0) 
                return new NullRate ();
            neue Rate zurückgeben (rateValue);
        }}
    }}

    öffentliche Klasse Rate
    {
        public int Value {get; einstellen; }}
        öffentlicher virtueller Bool HasValue {get {return (Wert> 0); }}
        public Rate (int value) {Wert = Wert; }}
    }}

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

Ihr Codebeispiel schlägt fehl. Wenn obj null ist, führt obj.ToString () zu einer Nullreferenzausnahme. Ich würde den Prozess abkürzen und zu Beginn Ihrer Hilfsfunktion nach einem Nullobjekt suchen. Was ist der Typ, den Sie für Ihre eigentliche Frage auf Null oder Null prüfen? Auf String gibt es eine großartige IsNullOrEmpty-Funktion. Mir scheint, dies wäre eine großartige Verwendung von Erweiterungsmethoden, um eine IsNullOrZero-Methode auf dem int zu implementieren. Art.

Edit: Erinnerst du dich an das '?' ist nur Compilerzucker für den Typ INullable, daher könnten Sie wahrscheinlich ein INullable als Parameter verwenden und es dann mit null (parm == null) vergleichen und wenn nicht null mit null vergleichen.

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

Vergessen Sie nicht, für Zeichenfolgen können Sie immer verwenden:

String.IsNullOrEmpty(str)

Anstatt:

str==null || str==""

Einen Schritt weiter von Joshua Shannons netter Antwort . Jetzt mit Verhinderung des Boxens / 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));
    }
}