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

根据MSDN中==运营商的文档，

对于预定义的值类型，相等运算符（==）如果其操作数的值相等，则返回true，否则返回false。对于字符串以外的引用类型，如果==的两个操作数引用同一对象，则==返回true。对于字符串类型，==比较字符串的值。用户定义的值类型可能会使==运算符重载（请参阅运算符）。用户定义的引用类型也可以，尽管 默认情况下==的行为与上述预定义和用户定义的引用类型相同。

那么，为什么此代码片段无法编译？

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

我收到错误运算符'=='不能应用于类型'T'和'T'的操作数。我不知道为什么，因为据我所知，该==操作符是为所有类型预定义的？

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

但是，如果我使用的是引用类型，==操作员会使用预定义的引用比较吗？如果定义了一个类型，它会使用操作员的重载版本吗？

编辑2：通过反复试验，我们了解到，==当使用无限制的泛型类型时，运算符将使用预定义的引用比较。实际上，编译器将使用它可以为受限类型参数找到的最佳方法，但是不再赘述。例如，true即使Test.test<B>(new B(), new B())被调用，下面的代码也将始终print ：

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

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

类型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），编译器就无法推断它应该使用重载运算符...尽管我认为即使不指定类型，编译器也将具有足够的信息来做出该决定。

就像其他人所说的那样，它仅在将T约束为引用类型时才有效。没有任何约束，您可以与null进行比较，但只能与null进行比较-对于不可为null的值类型，该比较将始终为false。

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

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

除了其他以外，这避免了装箱/铸造。

通常，EqualityComparer<T>.Default.Equals应该使用任何已实现的IEquatable<T>或具有明智Equals实现的方法来完成这项工作。

但是，如果==和Equals是出于某种原因实现方式不同，那么我的工作一般运营商应该是有用的; 它支持以下版本的操作员版本：

• 等于（T值1，T值2）
• NotEqual（T值1，T值2）
• 大于（T值1，T值2）
• 小于（T值1，T值2）
• GreaterThanOrEqual（T值1，T值2）
• LessThanOrEqual（T值1，T值2）

这么多答案，为什么没有一个解释呢？（乔凡尼明确提出的问题）...

.NET泛型不像C ++模板那样起作用。在C ++模板中，过载解析是在知道实际模板参数之后发生的。

在.NET泛型（包括C＃）中，将在不知道实际泛型参数的情况下进行重载解析。编译器可以用来选择要调用的函数的唯一信息来自通用参数的类型约束。

编译器无法知道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子句完成的。

似乎没有类约束：

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

在我的情况下，我想对相等运算符进行单元测试。我需要在相等运算符下调用代码，而无需显式设置泛型类型。建议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);
}

没有此的MSDN连接进入这里

Alex Turner的回复开始于：

不幸的是，此行为是设计使然，还没有一种简单的解决方案可以将==与可能包含值类型的类型参数一起使用。

如果要确保调用自定义类型的运算符，则可以通过反射来实现。只需使用您的通用参数获取类型，然后检索所需运算符的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});

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

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

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

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

上面的方法将起作用，因为在用户定义的引用类型的情况下==会得到照顾。
对于值类型，==可以被覆盖。在这种情况下，也应定义“！=“。

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

的 .Equals()同时工作对我来说TKey是一个泛型类型。

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


    // ...
}