C#中泛型参数的空值或默认比较

要处理所有类型的 T，包括其中 T 是原始类型，您需要在两种比较方法中进行编译：

    T Get<T>(Func<T> createObject)
    {
        T obj = createObject();
        if (obj == null || obj.Equals(default(T)))
            return obj;

        // .. do a bunch of stuff
        return obj;
    }

基于已接受答案的扩展方法。

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

用法：

   private bool SomeMethod(){
       var tValue = GetMyObject<MyObjectType>();
       if (tValue == null || tValue.IsDefault()) return false;
   }

与 null 交替以简化：

   public static bool IsNullOrDefault<T>(this T inObj)
   {
       if (inObj == null) return true;
       return EqualityComparer<T>.Default.Equals(inObj, default);
   }

用法：

   private bool SomeMethod(){
       var tValue = GetMyObject<MyObjectType>();
       if (tValue.IsNullOrDefault()) return false;
   }

这里会有问题——

如果您要允许它适用于任何类型，则 default(T) 对于引用类型将始终为 null，而对于值类型，default(T) 将始终为 0（或 struct full of 0）。

不过，这可能不是您所追求的行为。如果您希望它以通用方式工作，您可能需要使用反射来检查 T 的类型，并处理与引用类型不同的值类型。

或者，您可以对此设置接口约束，并且该接口可以提供一种方法来检查类/结构的默认值。

我认为您可能需要将此逻辑分成两部分并首先检查 null 。

public static bool IsNullOrEmpty<T>(T value)
{
    if (IsNull(value))
    {
        return true;
    }
    if (value is string)
    {
        return string.IsNullOrEmpty(value as string);
    }
    return value.Equals(default(T));
}

public static bool IsNull<T>(T value)
{
    if (value is ValueType)
    {
        return false;
    }
    return null == (object)value;
}

在 IsNull 方法中，我们依赖于 ValueType 对象根据定义不能为 null 的事实，因此如果 value 恰好是派生自 ValueType 的类，我们已经知道它不为 null。另一方面，如果它不是值类型，那么我们可以将转换为对象的值与 null 进行比较。我们可以通过直接转换为对象来避免对 ValueType 的检查，但这意味着值类型会被装箱，这是我们可能想要避免的，因为它意味着在堆上创建了一个新对象。

在 IsNullOrEmpty 方法中，我们正在检查字符串的特殊情况。对于所有其他类型，我们将值（已经知道不为空）与它的默认值进行比较，对于所有引用类型，默认值是空，对于值类型，通常是某种形式的零（如果它们是整数）。

使用这些方法，以下代码的行为可能与您预期的一样：

class Program
{
    public class MyClass
    {
        public string MyString { get; set; }
    }

    static void Main()
    {
        int  i1 = 1;    Test("i1", i1); // False
        int  i2 = 0;    Test("i2", i2); // True
        int? i3 = 2;    Test("i3", i3); // False
        int? i4 = null; Test("i4", i4); // True

        Console.WriteLine();

        string s1 = "hello";      Test("s1", s1); // False
        string s2 = null;         Test("s2", s2); // True
        string s3 = string.Empty; Test("s3", s3); // True
        string s4 = "";           Test("s4", s4); // True

        Console.WriteLine();

        MyClass mc1 = new MyClass(); Test("mc1", mc1); // False
        MyClass mc2 = null;          Test("mc2", mc2); // True
    }

    public static void Test<T>(string fieldName, T field)
    {
        Console.WriteLine(fieldName + ": " + IsNullOrEmpty(field));
    }

    // public static bool IsNullOrEmpty<T>(T value) ...

    // public static bool IsNull<T>(T value) ...
}

我用：

public class MyClass<T>
{
  private bool IsNull() 
  {
    var nullable = Nullable.GetUnderlyingType(typeof(T)) != null;
    return nullable ? EqualityComparer<T>.Default.Equals(Value, default(T)) : false;
  }
}

只是一个骇人听闻的答案，并作为对自己的提醒。但我发现这对我的项目很有帮助。我这样写的原因是因为如果值为 0，我不希望将默认整数 0 标记为 null

private static int o;
public static void Main()
{
    //output: IsNull = False -> IsDefault = True
    Console.WriteLine( "IsNull = " + IsNull( o ) + " -> IsDefault = " + IsDefault(o)); 
}

public static bool IsNull<T>(T paramValue)
{
  if( string.IsNullOrEmpty(paramValue + "" ))
    return true;
  return false;
}

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

不知道这是否符合您的要求，但您可以将 T 限制为实现 IComparable 等接口的类型，然后使用该接口中的 ComparesTo() 方法（IIRC 支持/处理空值）像这样：

public void MyMethod<T>(T myArgument) where T : IComparable
...
if (0 == myArgument.ComparesTo(default(T)))

您可能还可以使用其他接口 IEquitable 等。

@ilitirit：

public class Class<T> where T : IComparable
{
    public T Value { get; set; }
    public void MyMethod(T val)
    {
        if (Value == val)
            return;
    }
}

运算符“==”不能应用于“T”和“T”类型的操作数

如果没有显式的 null 测试，然后调用 Equals 方法或 object.Equals，我想不出一种方法，如上所述。

您可以使用 System.Comparison 设计一个解决方案，但实际上这最终会导致更多的代码行并大大增加复杂性。

我想你很接近。

if (myArgument.Equals(default(T)))

现在可以编译，但如果 myArgument 为空，则会失败，这是我正在测试的一部分。我可以像这样添加一个明确的空检查：

您只需要反转调用 equals 的对象即可获得优雅的 null 安全方法。

default(T).Equals(myArgument);