应该IEquatable、IComparable在非密封类上实施？

Question

任何人对于 IEquatable 或 IComparable 是否通常应要求 T 是密封有任何意见code>（如果它是一个类）？

因为我正在编写一组旨在帮助实现不可变类的基类，所以我想到了这个问题。基类旨在提供的部分功能是自动实现相等比较（使用类的字段以及可应用于字段来控制相等比较的属性）。当我完成时应该会很不错 - 我正在使用表达式树为每个 T 动态创建一个编译的比较函数，因此比较函数应该非常接近常规相等的性能比较功能。 （我使用以 System.Type 为键的不可变字典，并双重检查锁定以一种相当高性能的方式存储生成的比较函数）

不过，突然出现的一件事是要使用哪些函数检查成员字段的相等性。我最初的目的是检查每个成员字段的类型（我将其称为 X）是否实现 IEquatable。然而，经过一番思考，我认为除非 X 被 sealed ，否则使用起来不安全。原因是，如果 X 不是 sealed，我无法确定 X 是否适当地将相等性检查委托给虚拟方法X，从而允许子类型覆盖相等比较。

这就提出了一个更普遍的问题 - 如果类型没有密封，它真的应该实现这些接口吗？我认为不是，因为我认为接口契约是在两个 X 类型之间进行比较，而不是两个可能是也可能不是 X 的类型（尽管它们必须是当然是 X 或子类型）。

你们觉得怎么样？对于未密封的类，是否应该避免 IEquatable 和 IComparable？ （也让我想知道是否有一个 fxcop 规则）

我当前的想法是让我生成的比较函数仅在 T 为的成员字段上使用 IEquatable sealed，如果 T 未密封，则使用虚拟 Object.Equals(Object obj)，即使 T实现 IEquatable，因为该字段可能会存储 T 的子类型，并且我怀疑 IEquatable 的大多数实现是否适合为遗产。

Answer 1

我一直在思考这个问题，经过一番考虑后，我同意实现 IEquatable 和 IComparable 只能在密封上完成类型。

我来来回回想了一会儿，但后来我想到了下面的测试。在什么情况下以下内容应该返回 false？恕我直言，两个对象要么相等，要么不相等。

public void EqualitySanityCheck<T>(T left, T right) where T : IEquatable<T> {
  var equals1 = left.Equals(right);
  var equals2 = ((IEqutable<T>)left).Equals(right);
  Assert.AreEqual(equals1,equals2);
}

假设比较器具有等效类型，给定对象上的 IEquatable 结果应与 Object.Equals 具有相同的行为。在对象层次结构中实现两次 IEquatable 允许并暗示系统中有两种不同的方式来表达相等性。由于存在多个 IEquatable 实现，因此很容易设计出任意数量的 IEquatable 和 Object.Equals 不同的场景，但是只有一个Object.Equals。因此，上述操作将会失败，并在您的代码中造成一些混乱。

有些人可能会认为，在对象层次结构的较高位置实现 IEquatable是有效的，因为您想要比较对象属性的子集。在这种情况下，您应该青睐专为比较这些属性而设计的 IEqualityComparer。

Answer 2

我通常建议不要实施 IEquatable在任何非密封类上，或在大多数类上实现非泛型 IComparable，但对于 IComparable却不能说同样的情况。原因有两个：

1. 已经存在一种比较同一类型或不同类型的对象的方法：Object.Equals。由于 IEquatable不包括 GetHashCode，其行为本质上必须与 Object.Equals 的行为相匹配。实施 IEquatable的唯一原因是除了Object.Equals就是性能。 IEquatable当应用于密封类类型时，与 Object.Equals 相比，性能有微小的改进；而当应用于结构类型时，性能有很大的改进。然而，未密封类型的 IEquatable.Equals 实现可以确保其行为与可能重写的 Object.Equals 的行为相匹配的唯一方法是调用 Object.Equals。如果 IEquatable.Equals 必须调用 Object.Equals，则任何可能的性能优势都会消失。
   
2. 有时，基类具有仅涉及基类属性的定义的自然顺序是可能的、有意义的且有用的，这在所有子类中都是一致的。检查两个对象是否相等时，结果不应取决于将对象视为基类型还是派生类型。然而，在对对象进行排名时，结果通常应取决于用作比较基础的类型。派生类对象应实现 IComparable；但不应覆盖基类型的比较方法。当两个派生类对象作为父类型进行比较时，将其作为“无排名”进行比较是完全合理的，但当作为派​​生类型进行比较时，其中一个对象会高于另一个对象。

可继承类中非泛型 IComparable 的实现可能比 IComparable的实现更值得怀疑。如果不希望任何子类需要其他排序，那么最好的办法可能是允许基类实现它，但对于子类来说，不要重新实现或覆盖父类的实现。

Answer 3

我见过的大多数 Equals 实现都会检查正在比较的对象的类型，如果它们不相同，则该方法返回 false。

这巧妙地避免了子类型与其父类型进行比较的问题，从而无需密封类。

一个明显的例子是尝试将 2D 点 (A) 与 3D 点 (B) 进行比较：对于 2D，3D 点的 x 和 y 值可能相等，但对于 3D 点，z 值将很可能会有所不同。

这意味着 A == B 将为 true，但 B == A 将为 false。大多数人喜欢 Equals 运算符是可交换的，在这种情况下检查类型显然是一个好主意。

但是，如果您进行子类化并且不添加任何新属性怎么办？嗯，这个问题有点难回答，可能取决于你的情况。

Answer 4

我今天在阅读时偶然发现了这个话题
https://blog.mischel.com /2013/01/05/继承与可等同的-不要混合/
我同意，有理由不实现 IEquatable，因为它很可能会以错误的方式完成。

然而，在阅读链接的文章后，我测试了自己的实现，我在各种非密封的继承类上使用了它，我发现它工作正常。
在实现IEquatable时，我参考了这篇文章：
http://www.loganfranken.com/blog /687/overriding-equals-in-c-part-1/
它很好地解释了在 Equals() 中使用哪些代码。但它没有解决继承问题，所以我自己调整了它。这是结果。

并回答原来的问题：
我并不是说它应该在非密封类上实现，但我说它绝对可以毫无问题地实现。

//============================================================================
class CBase : IEquatable<CBase>
{
  private int m_iBaseValue = 0;

  //--------------------------------------------------------------------------
  public CBase (int i_iBaseValue)
  {
    m_iBaseValue = i_iBaseValue;
  }

  //--------------------------------------------------------------------------
  public sealed override bool Equals (object i_value)
  {
    if (ReferenceEquals (null, i_value))
      return false;
    if (ReferenceEquals (this, i_value))
      return true;

    if (i_value.GetType () != GetType ())
      return false;

    return Equals_EXEC ((CBase)i_value);
  }

  //--------------------------------------------------------------------------
  public bool Equals (CBase i_value)
  {
    if (ReferenceEquals (null, i_value))
      return false;
    if (ReferenceEquals (this, i_value))
      return true;

    if (i_value.GetType () != GetType ())
      return false;

    return Equals_EXEC (i_value);
  }

  //--------------------------------------------------------------------------
  protected virtual bool Equals_EXEC (CBase i_oValue)
  {
    return i_oValue.m_iBaseValue == m_iBaseValue;
  }
}

//============================================================================
class CDerived : CBase, IEquatable<CDerived>
{
  public int m_iDerivedValue = 0;

  //--------------------------------------------------------------------------
  public CDerived (int i_iBaseValue,
                  int i_iDerivedValue)
  : base (i_iBaseValue)
  {
    m_iDerivedValue = i_iDerivedValue;
  }

  //--------------------------------------------------------------------------
  public bool Equals (CDerived i_value)
  {
    if (ReferenceEquals (null, i_value))
      return false;
    if (ReferenceEquals (this, i_value))
      return true;

    if (i_value.GetType () != GetType ())
      return false;

    return Equals_EXEC (i_value);
  }

  //--------------------------------------------------------------------------
  protected override bool Equals_EXEC (CBase i_oValue)
  {
    CDerived oValue = i_oValue as CDerived;
    return base.Equals_EXEC (i_oValue)
        && oValue.m_iDerivedValue == m_iDerivedValue;
  }
}

测试：

private static void Main (string[] args)
{
// Test with Foo and Fooby for verification of the problem.
  // definition of Foo and Fooby copied from
  // https://blog.mischel.com/2013/01/05/inheritance-and-iequatable-do-not-mix/
  // and not added in this post
  var fooby1 = new Fooby (0, "hello");
  var fooby2 = new Fooby (0, "goodbye");
  Foo foo1 = fooby1;
  Foo foo2 = fooby2;

// all false, as expected
  bool bEqualFooby12a = fooby1.Equals (fooby2);
  bool bEqualFooby12b = fooby2.Equals (fooby1);
  bool bEqualFooby12c = object.Equals (fooby1, fooby2);
  bool bEqualFooby12d = object.Equals (fooby2, fooby1);

// 2 true (wrong), 2 false
  bool bEqualFoo12a = foo1.Equals (foo2);  // unexpectedly "true": wrong result, because "wrong" overload is called!
  bool bEqualFoo12b = foo2.Equals (foo1);  // unexpectedly "true": wrong result, because "wrong" overload is called!
  bool bEqualFoo12c = object.Equals (foo1, foo2);
  bool bEqualFoo12d = object.Equals (foo2, foo1);

// own test
  CBase oB = new CBase (1);
  CDerived oD1 = new CDerived (1, 2);
  CDerived oD2 = new CDerived (1, 2);
  CDerived oD3 = new CDerived (1, 3);
  CDerived oD4 = new CDerived (2, 2);

  CBase oB1 = oD1;
  CBase oB2 = oD2;
  CBase oB3 = oD3;
  CBase oB4 = oD4;

// all false, as expected
  bool bEqualBD1a = object.Equals (oB, oD1);
  bool bEqualBD1b = object.Equals (oD1, oB);
  bool bEqualBD1c = oB.Equals (oD1);
  bool bEqualBD1d = oD1.Equals (oB);

// all true, as expected
  bool bEqualD12a = object.Equals (oD1, oD2);
  bool bEqualD12b = object.Equals (oD2, oD1);
  bool bEqualD12c = oD1.Equals (oD2);
  bool bEqualD12d = oD2.Equals (oD1);
  bool bEqualB12a = object.Equals (oB1, oB2);
  bool bEqualB12b = object.Equals (oB2, oB1);
  bool bEqualB12c = oB1.Equals (oB2);
  bool bEqualB12d = oB2.Equals (oB1);

// all false, as expected
  bool bEqualD13a = object.Equals (oD1, oD3);
  bool bEqualD13b = object.Equals (oD3, oD1);
  bool bEqualD13c = oD1.Equals (oD3);
  bool bEqualD13d = oD3.Equals (oD1);
  bool bEqualB13a = object.Equals (oB1, oB3);
  bool bEqualB13b = object.Equals (oB3, oB1);
  bool bEqualB13c = oB1.Equals (oB3);
  bool bEqualB13d = oB3.Equals (oB1);

// all false, as expected
  bool bEqualD14a = object.Equals (oD1, oD4);
  bool bEqualD14b = object.Equals (oD4, oD1);
  bool bEqualD14c = oD1.Equals (oD4);
  bool bEqualD14d = oD4.Equals (oD1);
  bool bEqualB14a = object.Equals (oB1, oB4);
  bool bEqualB14b = object.Equals (oB4, oB1);
  bool bEqualB14c = oB1.Equals (oB4);
  bool bEqualB14d = oB4.Equals (oB1);
}