c# - Nullable types: лучший способ проверить нуль или ноль в c #





code-review zero (10)


class Item{  
 bool IsNullOrZero{ get{return ((this.Rate ?? 0) == 0);}}
}

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

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)){} // но вы не получаете от этого многого




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

String.IsNullOrEmpty(str)

Вместо:

str==null || str==""



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

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 - value type , допустим, double, default(t) равен 0d, поскольку bool - false , для char - '\0' и так далее ...




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

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

using System;
using System.Collections.Generic;

namespace NullObjectPatternTest
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var items = new List
                            {
                                new Item(RateFactory.Create(20)),
                                new Item(RateFactory.Create(null))
                            };

            PrintPricesForItems(items);
        }

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

    public abstract class ItemBase
    {
        public abstract Rate Rate { get; }
        public int GetPrice()
        {
            // There is NO need to check if Rate == 0 or Rate == null
            return 1 * Rate.Value;
        }
    }

    public class Item : ItemBase
    {
        private readonly Rate _Rate;
        public override Rate Rate { get { return _Rate; } }
        public Item(Rate rate) { _Rate = rate; }
    }

    public sealed class RateFactory
    {
        public static Rate Create(int? rateValue)
        {
            if (!rateValue || rateValue == 0) 
                return new NullRate();
            return new Rate(rateValue);
        }
    }

    public class Rate
    {
        public int Value { get; set; }
        public virtual bool HasValue { get { return (Value > 0); } }
        public Rate(int value) { Value = value; }
    }

    public class NullRate : Rate
    {
        public override bool HasValue { get { return false; } }
        public NullRate() : base(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, поскольку мы имеем дело с типами значений или структурами! Это также означает, что мы можем с уверенностью предположить, что значение TToCheck не будет равно нулю; Помните, что 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 (item.Rate.GetValueOrDefault() == 0) { }

Это решение

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




public static bool nz(object obj)
{
    return obj == null || obj.Equals(Activator.CreateInstance(obj.GetType()));
}



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

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




Если ваша (логическая) проверка предназначена для отрицания (!), И вы хотите захватить как JS null и undefined (поскольку разные браузеры предоставят вам разные результаты), вы будете использовать менее ограничительное сравнение: например:

var ItemID = Item.get_id();
if (ItemID != null)
{
 //do stuff
}

Это фиксирует как null и undefined





c# null code-review zero