我有两个解，它们很简单。

解决方案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)
   {
       // ...
       // ..
       // .
   }
}

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


    // ...
}

如果没有类约束:

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

应该意识到，虽然==操作符中的类约束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);
}

编译器不能知道T不是struct(值类型)。所以你必须告诉它它只能是参考类型，我认为:

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子句完成的。

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

类型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)，编译器不能推断它应该使用重载操作符…尽管我认为即使没有指定类型，它也有足够的信息来做出决定。