如何比较泛型类型的值？

Question

如何比较泛型类型的值？

我已将其减少到最小样本：

public class Foo<T> where T : IComparable
{
    private T _minimumValue = default(T);

    public bool IsInRange(T value) 
    {
        return (value >= _minimumValue); // <-- Error here
    }
}

错误是：

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

到底是什么！？ T 已经被限制为 IComparable，即使将其限制为值类型（where T: struct），我们仍然无法应用任何运算符 <、>、<=、>=、== 或<代码>！=。 （我知道 == 和 != 存在涉及 Equals() 的解决方法，但它对关系运算符没有帮助）。

那么，有两个问题：

1. 为什么我们会观察到这种奇怪的行为？是什么阻止我们比较已知为IComparable的泛型类型的值？难道它不会以某种方式破坏通用约束的全部目的吗？
2. 我该如何解决这个问题，或者至少解决这个问题？

（我意识到已经有一些与这个看似简单的问题相关的问题 - 但没有一个线程给出详尽或可行的答案，所以在这里。）

Answer 1

IComparable 不会重载 >= 运算符。你应该使用

value.CompareTo(_minimumValue) >= 0

Answer 2

如果 value 可以为 null，则当前答案可能会失败。使用类似这样的东西：

Comparer<T>.Default.Compare(value, _minimumValue) >= 0

Answer 3

运算符重载问题

不幸的是，接口不能包含重载的运算符。尝试在编译器中输入以下内容：

public interface IInequalityComaparable<T>
{
    bool operator >(T lhs, T rhs);
    bool operator >=(T lhs, T rhs);
    bool operator <(T lhs, T rhs);
    bool operator <=(T lhs, T rhs);
}

我不知道为什么他们不允许这样做，但我猜这会使语言定义变得复杂，并且用户很难正确实现。

要么是这样，要么是设计师不喜欢滥用的可能性。例如，想象一下对类 MagicMrMeow 进行 >= 比较。或者甚至在类 Matrix 上。这两个值的结果意味着什么？尤其是当可能存在歧义时？

官方解决方法

由于上述接口不合法，我们有 IComparable 接口来解决该问题。它不实现任何运算符，并且仅公开一种方法，int CompareTo(T other);

请参阅http://msdn.microsoft.com/en-us/library/4d7sx9hd.aspx

int 结果实际上是一个三位或三进制（类似于 Boolean，但具有三种状态）。下表解释了结果的含义：

Value              Meaning

Less than zero     This object is less than
                   the object specified by the CompareTo method.

Zero               This object is equal to the method parameter.

Greater than zero  This object is greater than the method parameter.

使用解决方法

为了执行与 value >= _minimumValue 相同的操作，您必须改为编写：

value.CompareTo(_minimumValue) >= 0

Answer 4

public bool IsInRange(T value) 
{
    return (value.CompareTo(_minimumValue) >= 0);
}

使用 IComparable 泛型时，所有小于/大于运算符都需要转换为对 CompareTo 的调用。无论您使用什么运算符，请保持按相同顺序比较值，并与零进行比较。 （xy 变为 x.CompareTo(y)0，其中 为 >、>= 等）

另外，我建议您使用的通用约束是 where T : IComparable。 IComparable 本身意味着该对象可以与任何对象进行比较，将一个对象与相同类型的其他对象进行比较可能更合适。

Answer 5

使用 Comparer 类代替 value >= _minimValue：

public bool IsInRange(T value ) {
    var result = Comparer<T>.Default.Compare(value, _minimumValue);
    if ( result >= 0 ) { return true; }
    else { return false; }
}

Answer 6

正如其他人所说，需要显式使用 CompareTo 方法。不能使用带有运算符的接口的原因是，一个类可以实现任意数量的接口，而它们之间没有明确的排名。假设有人试图计算表达式“a = foo + 5;”当 foo 实现了六个接口时，所有这些接口都定义了带有整数第二个参数的运算符“+”；操作员应该使用哪个接口？

类可以派生多个接口这一事实使得接口非常强大。不幸的是，它常常迫使人们更加明确地表达自己真正想做的事情。

Answer 7

IComparable 仅强制使用名为 CompareTo() 的函数。所以你不能应用你提到的任何运算符

Answer 8

我能够使用 Peter Hedberg 的答案为泛型创建一些重载的扩展方法。请注意，CompareTo 方法在这里不起作用，因为类型 T 未知并且不提供该接口。也就是说，我有兴趣看到任何替代方案。

[DebuggerStepThrough]
public void RemoveDuplicates<T>(this List<T> Instance)
{
  Instance.RemoveDuplicates((X, Y) => Comparer<T>.Default.Compare(X, Y));
}

[DebuggerStepThrough]
public void RemoveDuplicates<T>(this List<T> Instance, Comparison<T> Comparison)
{
  Instance.RemoveDuplicates(new List<Comparison<T>>() { Comparison });
}

[DebuggerStepThrough]
public void RemoveDuplicates<T>(this List<T> Instance, List<Comparison<T>> Comparisons)
{
  List<bool> oResults = new List<bool>();

  for (int i = 0; i <= Instance.Count - 1; i++)
  {
    for (int j = Instance.Count - 1; j >= i + 1; j += -1)
    {
      oResults.Clear();

      foreach (Comparison<T> oComparison in Comparisons)
        oResults.Add(oComparison(Instance[i], Instance[j]) == 0);

      if (oResults.Any(R => R))
        Instance.RemoveAt(j);
    }
  }
}

--编辑--

我能够通过将所有方法上的 T 限制为 IComparable(Of T) 来清理这个问题，如 OP 所示。请注意，此约束也需要类型 T 来实现 IComparable(Of)。

[DebuggerStepThrough]
public void RemoveDuplicates<T>(this List<T> Instance) where T : IComparable<T>
{
    Instance.RemoveDuplicates((X, Y) => X.CompareTo(Y));
}