运算符 == 不能应用于 C# 中的泛型类型吗？

Question

根据 MSDN< 中 == 运算符的文档/a>,

对于预定义值类型， 相等运算符 (==) 返回 true，如果 其操作数的值相等， 否则为假。 对于参考类型 除了字符串之外，如果满足以下条件则 == 返回 true 它的两个操作数引用相同的 目的。 对于字符串类型，== 比较字符串的值。 用户定义的值类型可以重载 == 运算符（请参阅运算符）。 所以可以 用户定义的引用类型，尽管 默认情况下 == 的行为如所描述的 以上对于预定义和 用户定义的引用类型。

那么为什么这段代码无法编译呢？

bool Compare<T>(T x, T y) { return x == y; }

我收到错误运算符“==”无法应用于类型“T”和“T”的操作数。 我想知道为什么，因为据我了解 == 运算符是为所有类型预定义的？

编辑：谢谢大家。 我一开始并没有注意到该声明仅涉及引用类型。 我还认为为所有值类型提供了逐位比较，但我现在知道这是不正确的。

但是，如果我使用引用类型，== 运算符会使用预定义的引用比较，还是会使用该运算符的重载版本（如果类型已定义）？

编辑2：通过反复试验，我们了解到==运算符在使用不受限制的泛型类型时将使用预定义的引用比较。 实际上，编译器将使用它能为受限类型参数找到的最佳方法，但不会再进一步​​寻找。 例如，下面的代码将始终打印 true，即使调用 Test.test(new B(), new B()) 也是如此：

class A { public static bool operator==(A x, A y) { return true; } }
class B : A { public static bool operator==(B x, B y) { return false; } }
class Test { void test<T>(T a, T b) where T : A { Console.WriteLine(a == b); } }

Answer 1

正如其他人所说，只有当 T 被限制为引用类型时它才会起作用。 在没有任何约束的情况下，您可以与 null 进行比较，但只能与 null 进行比较 - 对于不可为 null 的值类型，该比较始终为 false。

最好使用 IComparer，而不是调用 Equals - 如果您没有更多信息，EqualityComparer.Default 是一个不错的选择：

public bool Compare<T>(T x, T y)
{
    return EqualityComparer<T>.Default.Equals(x, y);
}

除了除此之外，这可以避免拳击/选角。

Answer 2

“...默认情况下 == 的行为如上所述，适用于预定义和用户定义的引用类型。”

类型 T 不一定是引用类型，因此编译器无法做出该假设。

但是，这会编译，因为它更明确：

    bool Compare<T>(T x, T y) where T : class
    {
        return x == y;
    }

跟进其他问题，“但是，如果我使用引用类型， == 运算符会使用预定义的引用比较，还是会使用如果类型定义了运算符，则该运算符的重载版本？”

我本以为泛型上的 == 会使用重载版本，但以下测试演示了其他情况。 有趣...我很想知道为什么！ 如果有人知道请分享。

namespace TestProject
{
 class Program
 {
    static void Main(string[] args)
    {
        Test a = new Test();
        Test b = new Test();

        Console.WriteLine("Inline:");
        bool x = a == b;
        Console.WriteLine("Generic:");
        Compare<Test>(a, b);

    }


    static bool Compare<T>(T x, T y) where T : class
    {
        return x == y;
    }
 }

 class Test
 {
    public static bool operator ==(Test a, Test b)
    {
        Console.WriteLine("Overloaded == called");
        return a.Equals(b);
    }

    public static bool operator !=(Test a, Test b)
    {
        Console.WriteLine("Overloaded != called");
        return a.Equals(b);
    }
  }
}

输出

内联：
重载==称为

通用：

按任意键继续。 。 。

后续 2

我确实想指出，更改比较方法会

    static bool Compare<T>(T x, T y) where T : Test
    {
        return x == y;
    }

导致调用重载的 == 运算符。 我想如果没有指定类型（作为 where），编译器无法推断它应该使用重载运算符...尽管我认为它有足够的信息来做出该决定即使没有指定类型。

Answer 3

一般来说，EqualityComparer.Default.Equals 应该使用任何实现 IEquatable 或具有合理 Equals 的内容来完成这项工作> 实施。

但是，如果由于某种原因 == 和 Equals 的实现方式不同，那么我在 通用运算符 应该很有用； 它支持以下运算符版本（除其他外）：

• Equal(T value1, T value2)
• NotEqual(T value1, T value2)
• GreaterThan(T value1, T value2)
• LessThan(T value1, T value2)
• GreaterThanOrEqual(T 值1, T 值2)
• LessThanOrEqual(T 值1, T 值2)

Answer 4

这么多答案，却没有一个解释为什么？ （Giovanni 明确要求）....

NET 泛型的行为与 C++ 模板不同。 在 C++ 模板中，重载解析发生在已知实际模板参数之后。

在 .NET 泛型（包括 C#）中，重载解析发生时不知道实际的泛型参数。 编译器可以用来选择要调用的函数的唯一信息来自泛型参数的类型约束。

Answer 5

编译器无法知道 T 不可能是结构（值类型）。 所以你必须告诉它它只能是引用类型，我认为：

bool Compare<T>(T x, T y) where T : class { return x == y; }

这是因为如果 T 可以是值类型，则可能存在 x == y 格式错误的情况 - 在以下情况下类型没有定义运算符 ==。 同样的情况也会发生，这更明显：

void CallFoo<T>(T x) { x.foo(); }

这也会失败，因为你可以传递一个没有函数 foo 的类型 T。 C# 强制您确保所有可能的类型始终具有函数 foo。 这是通过 where 子句完成的。

Answer 6

看来没有类约束：

bool Compare<T> (T x, T y) where T: class
{
    return x == y;
}

人们应该意识到，虽然 class 约束 == 运算符中的 Equals 继承自 Object.Equals，而结构体的则覆盖 ValueType.Equals。

请注意：

bool Compare<T> (T x, T y) where T: struct
{
    return x == y;
}

也会给出相同的编译器错误。

到目前为止，我不明白为什么编译器会拒绝值类型相等运算符比较。 但我确实知道一个事实，这是有效的：

bool Compare<T> (T x, T y)
{
    return x.Equals(y);
}

Answer 7

您可以使用 C# 11 和 .NET 7+ 来执行此操作：（

    static void Main()
    {
        Console.WriteLine(Compare(2, 2));
        Console.WriteLine(Compare(2, 3));
    }
    static bool Compare<T>(T x, T y) where T : IEqualityOperators<T, T, bool>
    {
        return x == y;
    }

您可能更喜欢使用 where T : INumber，它涵盖了此场景以及更多内容，但这取决于您的具体需求；并非所有可等式类型都是数字）

Answer 8

就我而言，我想对相等运算符进行单元测试。 我需要在相等运算符下调用代码，而无需显式设置泛型类型。 对 EqualityComparer 的建议没有帮助，因为 EqualityComparer 调用了 Equals 方法，但没有调用相等运算符。

以下是我如何通过构建 LINQ 来处理泛型类型。 它为 == 和 != 运算符调用正确的代码：

/// <summary>
/// Gets the result of "a == b"
/// </summary>
public bool GetEqualityOperatorResult<T>(T a, T b)
{
    // declare the parameters
    var paramA = Expression.Parameter(typeof(T), nameof(a));
    var paramB = Expression.Parameter(typeof(T), nameof(b));
    // get equality expression for the parameters
    var body = Expression.Equal(paramA, paramB);
    // compile it
    var invokeEqualityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile();
    // call it
    return invokeEqualityOperator(a, b);
}

/// <summary>
/// Gets the result of "a =! b"
/// </summary>
public bool GetInequalityOperatorResult<T>(T a, T b)
{
    // declare the parameters
    var paramA = Expression.Parameter(typeof(T), nameof(a));
    var paramB = Expression.Parameter(typeof(T), nameof(b));
    // get equality expression for the parameters
    var body = Expression.NotEqual(paramA, paramB);
    // compile it
    var invokeInequalityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile();
    // call it
    return invokeInequalityOperator(a, b);
}

Answer 9

这里有一个 MSDN Connect 条目

Alex Turner 的回复开始和：

不幸的是，这种行为是由
设计并没有一个简单的
启用 == 与类型一起使用的解决方案
可能包含值的参数
类型。

Answer 10

如果您想确保调用自定义类型的运算符，您可以通过反射来实现。 只需使用泛型参数获取类型并检索所需运算符的 MethodInfo（例如 op_Equality、op_Inequality、op_LessThan...）。

var methodInfo = typeof (T).GetMethod("op_Equality", 
                             BindingFlags.Static | BindingFlags.Public);    

然后使用 MethodInfo 的 Invoke 方法执行运算符并传入对象作为参数。

var result = (bool) methodInfo.Invoke(null, new object[] { object1, object2});

这将调用您的重载运算符，而不是由应用于泛型参数的约束定义的运算符。 可能不实用，但在使用包含几个测试的通用基类时，可以方便地对操作员进行单元测试。

Answer 11

我根据最新的 msdn 编写了以下函数。 它可以轻松比较两个对象x和y：

static bool IsLessThan(T x, T y) 
{
    return ((IComparable)(x)).CompareTo(y) <= 0;
}

Answer 12

bool Compare(T x, T y) where T : class { return x == y; }

上面的代码会起作用，因为在用户定义的引用类型的情况下会处理 ==。
对于值类型，可以覆盖 ==。 在这种情况下，还应该定义“!=”。

我认为这可能是原因，它不允许使用“==”进行通用比较。

Answer 13

.Equals() 对我有用，而 TKey 是通用类型。

public virtual TOutputDto GetOne(TKey id)
{
    var entity =
        _unitOfWork.BaseRepository
            .FindByCondition(x => 
                !x.IsDelete && 
                x.Id.Equals(id))
            .SingleOrDefault();


    // ...
}

Answer 14

我有两个解决方案，而且都很简单。

解决方案 1：将泛型类型变量转换为 object 并使用 == 运算符。

示例：

void Foo<T>(T t1, T t2)
{
   object o1 = t1;
   object o2 = t2;
   if (o1 == o2)
   {
      // ...
      // ..
      // . 
   }
}

解决方案 2：使用 object.Equals(object, object) 方法。

例子：

void Foo<T>(T t1, T t2)
{
   if (object.Equals(t1, t2)
   {
       // ...
       // ..
       // .
   }
}