Типы, допускающие значение NULL: лучший способ проверить нулевое или нулевое значение в с #

Я работаю над проектом, в котором я проверяю следующее во многих-многих местах:

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

больше из любопытства, чем что-либо еще, как лучше всего проверить оба случая?

Я добавил вспомогательный метод:

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

Есть ли способ лучше?

мне нравится if ((item.Rate ?? 0) == 0) { }

Обновление 1:

Вы также можете определить метод расширения, например:

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

И используйте это так:

if(item.IsNullOrValue(0)){} // но от этого мало что получится

Использование дженериков:

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

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

Если Tэто ссылочный тип , valueбудет сравниваться с null( default(T)), в противном случае, если Tэто a value type, скажем, double, default(t)это 0d, для bool есть false, для char '\0'и так далее ...

Хотя мне очень нравится принятый ответ, я думаю, что для полноты следует упомянуть и этот вариант:

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

Это решение

• не требует дополнительного метода,
• выполняется быстрее, чем все другие параметры, поскольку GetValueOrDefault - это операция чтения одного поля ¹ и
• читается легче чем ((item.Rate ?? 0) == 0)(хотя это может быть дело вкуса).

¹ Однако это не должно повлиять на ваше решение, поскольку такие виды микрооптимизации вряд ли что-то изменит.

Это действительно просто расширение принятого ответа Фредди Риоса только с использованием 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));
}

ПРИМЕЧАНИЕ: нам не нужно проверять значение по умолчанию (T) на null, поскольку мы имеем дело либо с типами значений, либо со структурами! Это также означает, что мы можем с уверенностью предположить, что T valueToCheck не будет нулевым; Помните здесь, что T? является сокращением Nullable <T>, поэтому, добавляя расширение к Nullable <T>, мы получаем метод в int ?, double ?, bool? и т.п.

Примеры:

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

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

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

Я согласен с использованием ?? оператор.

Если вы имеете дело со строками, используйте if (String.IsNullOrEmpty (myStr))

Есть ли способ лучше?

Что ж, если вы действительно ищете лучший способ, вы, вероятно, можете добавить еще один уровень абстракции поверх Rate. Вот кое-что, что я только что придумал, используя Nullable Design Pattern.

используя Систему;
using System.Collections.Generic;

пространство имен NullObjectPatternTest
{
    Программа публичного класса
    {
        public static void Main (string [] args)
        {
            var items = новый список
                            {
                                новый предмет (RateFactory.Create (20)),
                                новый элемент (RateFactory.Create (null))
                            };

            PrintPricesForItems (элементы);
        }

        private static void PrintPricesForItems (элементы IEnumerable)
        {
            foreach (элемент var в элементах)
                Console.WriteLine ("Цена предмета: {0: C}", item.GetPrice ());
        }
    }

    открытый абстрактный класс ItemBase
    {
        общедоступная аннотация Rate Rate {get; }
        public int GetPrice ()
        {
            // НЕ нужно проверять, если Rate == 0 или Rate == null
            return 1 * Rate.Value;
        }
    }

    открытый класс Item: ItemBase
    {
        частный только для чтения Rate _Rate;
        публичное переопределение Rate Rate {get {return _Rate; }}
        общедоступный элемент (ставка) {_Rate = ставка; }
    }

    общедоступный запечатанный класс RateFactory
    {
        public static Rate Create (int? rateValue)
        {
            если (! rateValue || rateValue == 0) 
                return new NullRate ();
            вернуть новую ставку (rateValue);
        }
    }

    публичный класс Ставка
    {
        public int Value {получить; набор; }
        общедоступный виртуальный логический объект HasValue {получить {возврат (значение> 0); }}
        public Rate (int value) {Value = value; }
    }

    открытый класс NullRate: Rate
    {
        общественное переопределение bool HasValue {получить {вернуть ложь; }}
        public NullRate (): base (0) {}
    }
}

Образец кода не удастся. Если obj имеет значение null, obj.ToString () приведет к исключению нулевой ссылки. Я бы сократил процесс и проверил наличие нулевого объекта в начале вашей вспомогательной функции. Что касается вашего фактического вопроса, какой тип вы проверяете на ноль или ноль? В String есть отличная функция IsNullOrEmpty, мне кажется, это было бы отличным использованием методов расширения для реализации метода IsNullOrZero в int? тип.

Изменить: Помните, "?" - это просто сахар компилятора для типа INullable, поэтому вы, вероятно, можете взять INullable в качестве parm, а затем jsut сравнить его с нулем (parm == null), а если не null, сравнить с нулем.

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

Не забывайте, что для строк всегда можно использовать:

String.IsNullOrEmpty(str)

Вместо:

str==null || str==""

На шаг дальше от красивого ответа Джошуа Шеннона . Теперь с предотвращением бокса / распаковки :

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