C#：GenericType == null 的替代方案

Question

我需要检查通用对象是否为空或默认（T）。 但我有一个问题...目前我是这样做的：

if (typeof(T).IsValueType)
{
  if(default(T).Equals(thing))
    // Do something
  else
    // Do something else
}
else
{
  if(thing == null)
    // Do something
  else
    // Do something else
}

但后来我最终重复自己...我不喜欢。 问题如下：

thing == null;

这里 ReSharper 警告可能将值类型与“null”进行比较。

thing == default(T);

这里我得到编译器错误：无法将运算符“==”应用于类型“T”和“T”的操作数。

thing.Equals(null|default(T));

thing 显然可以为 null（这就是我必须检查的原因！），因此会导致 NullReferenceException。

null|default(T).Equals(thing);

null 和 default(T) 通常也为 null...

有没有一种干净的方法来做到这一点？

Answer 1

正确的做法是：

return EqualityComparer<T>.Default.Equals(value, default(T))

不打拳击。 您甚至可以像这样定义一个扩展方法：

public static void bool IsDefault<T>(this T value)
{
    return EqualityComparer<T>.Default.Equals(value, default(T));
}

.. 并像这样调用它：

return entry.IsDefault();

不过，我个人不关心 T 上的扩展方法（例如这个对象 IsNull()），因为它有时会妨碍可读性。

Answer 2

如果拳击不是问题，您可以使用：

object.Equals(value, default(T))

Answer 3

当我需要测试该值是否为 NULL 时，我使用下面的方法。 我通常在调用采用任何类型但不包括空值的方法（例如缓存）时使用此方法。

public static bool IsNull<T>(this T value)
{
    var type = typeof(T);

    return (type.IsClass || Nullable.GetUnderlyingType(type) != null) 
        && EqualityComparer<T>.Default.Equals(value, default(T));

}

Answer 4

打一点拳击就可以了。

    static bool IsNullOrDefault<T>(T value)
    {
        return ((object)default(T)) == null ?
            ((object)value) == null :
            default(T).Equals(value);
    }

Answer 5

我目前能想到的最好的事情是：

return value == null || value.Equals(default(T));

编辑：

显然，有一个我不知道的静态 object.Equals 方法：

return object.Equals(value, default(T));

这更好。

Answer 6

您可以通过注意可以静态确定类型的可为空性来完全避免装箱。

您可以执行以下操作：

1. 在泛型类中声明一个名为 isDefault 的私有静态只读变量，其类型为 Predicate
2. 向您的泛型类添加一个静态初始值设定项，检查 T 的可为空性，并根据结果将 isDefault 设置为 v==null 或 default(T).Equals(v)
3. 使用 isDefault(x ) 而不是代码其余部分中的 x==null

下面是一个示例：

public class Example<T> {

    private static readonly Predicate<T> isDefault;

    static Example() {
        // Nullability check is a bit ugly, but we do it once per T,
        // so what the heck...
        if (typeof(T).IsValueType &&
           (!typeof(T).IsGenericType
        ||  typeof(T).GetGenericTypeDefinition() != typeof(Nullable<>)
        )) {
            // This is safe because T is not null
            isDefault = val => default(T).Equals(val);
        } else {
            // T is not a value type, so its default is null
            isDefault = val => val == null;
        }
    }

    public bool Check(T value) {
        // Now our null-checking is both good-looking and efficient
        return isDefault(value);
    }

}

Answer 7

通过测试：

public class DefaultOrNullChecker<T>  {
    public bool Check(object x) {
        return object.ReferenceEquals(x, null) || x.Equals(default(T));
    }
}
[TestFixture]
public class Tests {
    [Test]  public void when_T_is_reference_type() { 
        Assert.IsFalse(new DefaultOrNullChecker<Exception>().Check(new Exception()));}
    [Test] public void when_T_is_value_type() { 
        Assert.IsFalse(new DefaultOrNullChecker<int>().Check(123)); }
    [Test] public void when_T_is_null() {
        Assert.IsTrue(new DefaultOrNullChecker<Exception>().Check(null));}
    [Test] public void when_T_is_default_value() { 
        Assert.IsTrue(new DefaultOrNullChecker<int>().Check(0)); }
}

Answer 8

这有什么问题吗？

if (thing == default(T)) { }

如果它是值类型，那么 JIT 将简单地完全删除该语句。