什么是“最佳实践”？ 用于比较引用类型的两个实例？

Question

我最近遇到了这个问题，到目前为止，我一直很高兴地重写相等运算符（==）和/或Equals方法，以查看两个引用类型是否实际包含相同的数据（即看起来相同的两个不同实例）。

自从我更多地进行自动化测试（将参考/预期数据与返回的数据进行比较）以来，我一直在更多地使用它。

查看 MSDN 中的一些编码标准指南 我遇到了一篇文章，建议不要这样做。 现在我明白为什么这篇文章这么说（因为它们不是同一个实例），但它没有回答这个问题：

1. 最好的比较方法是什么两种引用类型？
2. 我们应该实现IComparable吗？ （我还看到提到这应该只保留给值类型）。
3. 有什么我不知道的接口吗？
4. 我们应该自己推出吗？

非常感谢 ^_^

更新

看起来我误读了一些文档（这是漫长的一天）并覆盖 等于 可能是正确的选择..

如果您正在实施参考 类型，你应该考虑覆盖 引用类型的 Equals 方法 如果您的类型看起来像基本类型 例如点、字符串、BigNumber、 等等。 大多数引用类型应该 不要重载相等运算符， 即使如果它们覆盖 Equals。 然而， 如果您正在实施参考 旨在具有价值的类型 语义，例如复数 类型，你应该覆盖相等性 运算符。

Answer 1

在 .NET 中正确、高效地实现平等并且没有代码重复是很困难的。 具体来说，对于具有值语义的引用类型（即 将等价视为相等的不可变类型），您应该实现 System.IEquatable 接口，您应该实现所有不同的操作（Equals、GetHashCode 和 ==、!=）。

例如，下面是一个实现值相等的类：

class Point : IEquatable<Point> {
    public int X { get; }
    public int Y { get; }

    public Point(int x = 0, int y = 0) { X = x; Y = y; }

    public bool Equals(Point other) {
        if (other is null) return false;
        return X.Equals(other.X) && Y.Equals(other.Y);
    }

    public override bool Equals(object obj) => Equals(obj as Point);

    public static bool operator ==(Point lhs, Point rhs) => object.Equals(lhs, rhs);

    public static bool operator !=(Point lhs, Point rhs) => ! (lhs == rhs);

    public override int GetHashCode() => HashCode.Combine(X, Y);
}

上面代码中唯一可移动的部分是粗体部分：Equals(Point other) 中的第二行和 GetHashCode()代码>方法。 其他代码应保持不变。

对于不表示不可变值的引用类，不要实现运算符 == 和 !=。 相反，使用它们的默认含义，即比较对象身份。

代码有意甚至等同于派生类类型的对象。 通常，这可能是不可取的，因为基类和派生类之间的相等性没有明确定义。 不幸的是，.NET 和编码指南在这里不是很清楚。 Resharper 创建的代码（在另一个答案中发布）在这种情况下很容易出现不良行为，因为 Equals (object x) 和 Equals(SecurableResourcePermission x) 将以不同的方式处理这种情况。

为了改变这种行为，必须在上面的强类型 Equals 方法中插入额外的类型检查：

public bool Equals(Point other) {
    if (other is null) return false;
    if (other.GetType() != GetType()) return false;
    return X.Equals(other.X) && Y.Equals(other.Y);
}

Answer 2

看起来您正在使用 C# 进行编码，它有一个名为 Equals 的方法，您的类应该实现该方法，如果您想使用“这两个指针（因为对象句柄就是指针）”之外的其他指标来比较两个对象，相同的内存地址？”。

我从此处获取了一些示例代码：

class TwoDPoint : System.Object
{
    public readonly int x, y;

    public TwoDPoint(int x, int y)  //constructor
    {
        this.x = x;
        this.y = y;
    }

    public override bool Equals(System.Object obj)
    {
        // If parameter is null return false.
        if (obj == null)
        {
            return false;
        }

        // If parameter cannot be cast to Point return false.
        TwoDPoint p = obj as TwoDPoint;
        if ((System.Object)p == null)
        {
            return false;
        }

        // Return true if the fields match:
        return (x == p.x) && (y == p.y);
    }

    public bool Equals(TwoDPoint p)
    {
        // If parameter is null return false:
        if ((object)p == null)
        {
            return false;
        }

        // Return true if the fields match:
        return (x == p.x) && (y == p.y);
    }

    public override int GetHashCode()
    {
        return x ^ y;
    }
}

Java有非常相似的机制。 equals() 方法是 Object 类的一部分，如果您需要这种类型的功能，您的类会重载它。

对于对象来说，重载“==”可能不是一个好主意，因为通常您仍然希望能够进行“这些是相同的指针”比较。 例如，通常依赖这些来将元素插入到不允许重复的列表中，并且如果该运算符以非标准方式重载，则某些框架内容可能无法工作。

Answer 3

下面我总结了实现 IEquatable 时需要执行的操作，并提供了各个 MSDN 文档页面的理由。

---

总结

• 当需要测试值相等性时（例如在集合中使用对象时），您应该实现 IEquatable 接口，为您的类重写 Object.Equals 和 GetHashCode。
• 当需要测试引用相等性时，您应该使用operator==、operator!=和Object.ReferenceEquals。
• 您应该仅覆盖 ValueTypes 和不可变的引用类型。

---

理由

IEquatable

System.IEquatable 接口用于比较对象的两个实例是否相等。 根据类中实现的逻辑来比较对象。 比较结果产生一个布尔值，指示对象是否不同。 这与 System.IComparable 接口形成对比，后者返回一个整数，指示对象值有何不同。

IEquatable 接口声明了两个必须重写的方法。 Equals 方法包含执行实际比较的实现，如果对象值相等则返回 true，如果不相等则返回 false。 GetHashCode 方法应返回一个唯一的哈希值，该值可用于唯一标识包含不同值的相同对象。 使用的散列算法的类型是特定于实现的。

IEquatable.Equals 方法

• 您应该为您的对象实现 IEquatable，以处理它们存储在数组或通用集合中的可能性。
• 如果实现 IEquatable，还应该重写 Object.Equals(Object) 和 GetHashCode 的基类实现，以便它们的行为与 IEquatable.Equals 方法的行为一致

重写 Equals() 和运算符 == 的指南（C# 编程指南）

• x.Equals(x) 返回 true。
• x.Equals(y) 返回与 y.Equals(x) 相同的值
• 如果 (x.Equals(y) && y.Equals(z)) 返回 true，则 x.Equals(z) 返回 true。
• 连续调用 x。 只要 x 和 y 引用的对象未被修改，Equals (y) 就会返回相同的值。
• x。 Equals (null) 返回 false（仅适用于不可为 null 的值类型。有关详细信息，请参阅 可空类型（C# 编程指南）。）
• Equals 的新实现不应引发异常。
• 建议任何重写 Equals 的类也重写 Object.GetHashCode。
• 建议除了实现 Equals(object) 之外，任何类还为自己的类型实现 Equals(type)，以提高性能。

默认情况下，运算符 == 通过确定两个引用是否指示同一对象来测试引用相等性。因此，引用类型不必实现运算符 == 即可获得此功能。 当类型不可变时，即实例中包含的数据无法更改时，重载运算符 == 来比较值相等而不是引用相等可能很有用，因为作为不可变对象，它们可以被视为与 long 相同因为它们具有相同的值。 在非不可变类型中重写运算符 == 不是一个好主意。

• 重载运算符 == 实现不应引发异常。
• 任何重载运算符 == 的类型也应该重载运算符 !=。

== 运算符（C# 参考）

• 对于预定义值类型，如果操作数的值相等，则相等运算符 (==) 返回 true，否则返回 false。
• 对于字符串以外的引用类型，如果两个操作数引用同一个对象，则 == 返回 true。
• 对于字符串类型，== 比较字符串的值。
• 在运算符 == 覆盖中使用 == 比较测试 null 时，请确保使用基对象类运算符。 如果不这样做，就会发生无限递归，导致堆栈溢出。

Object.Equals 方法（对象）

如果您的编程语言支持运算符重载，并且您选择重载给定类型的相等运算符，则该类型必须重写 Equals 方法。 Equals 方法的此类实现必须返回与相等运算符相同的结果

以下准则用于实现值类型：

• 考虑重写 Equals，以获得比 ValueType 上 Equals 默认实现所提供的更高的性能。
• 如果您重写 Equals 并且该语言支持运算符重载，则必须重载您的值类型的等于运算符。

以下准则用于实现引用类型：

• 如果类型的语义基​​于该类型表示某些值，请考虑重写引用类型上的 Equals。
• 大多数引用类型不得重载相等运算符，即使它们覆盖 Equals。 但是，如果您要实现旨在具有值语义的引用类型（例如复数类型），则必须重写相等运算符。

---

其他陷阱

• 当重写 GetHashCode() 时，请确保在哈希代码中使用引用类型之前测试 NULL。
• 我遇到了此处描述的基于接口的编程和运算符重载的问题： C# 中基于接口编程的运算符重载

Answer 4

微软似乎改变了他们的态度，或者至少存在关于不重载相等运算符的冲突信息。 根据这篇 Microsoft 文章，标题为“How to: Define Value Equality for a类型：

“== 和 != 运算符可以与类一起使用，即使类没有重载它们。但是，默认行为是执行引用相等性检查。在类中，如果重载 Equals 方法，则应该重载 == 和 != 运算符，但这不是必需的。”

根据 Eric Lippert 在他对我提出的有关 回答中的说法questions/32172273/minimal-code-for-equality-in-c-sharp">C# 中平等的最小代码 - 他说：

“这里遇到的危险是你得到了一个定义为 == 的运算符默认情况下引用相等的情况很容易出现这样的情况：重载的 Equals 方法实现值相等，而 == 实现引用相等，然后您意外地对值相等的非引用相等的事物使用了引用相等。这是一种容易出错的做法，很难通过人工代码审查来发现。

几年前，我研究了一种静态分析算法来统计检测这种情况，我们发现每百万行代码中的缺陷率约为两个实例。在我们研究的所有代码库中，当仅考虑在某些地方重写了 Equals 的代码库时，缺陷率显然要高得多！

此外，还要考虑成本与风险。 如果您已经实现了 IComparable，那么编写所有运算符只是简单的一行代码，不会有错误，也永远不会更改。 这是您要编写的最便宜的代码。 如果要在编写和测试十几个小方法的固定成本与查找和修复使用引用相等而不是值相等的难以发现的错误的无限成本之间进行选择，我知道我会选择哪一个。”

.NET Framework 永远不会对您编写的任何类型使用 == 或 != 但是，如果其他人这样做，会发生什么情况，所以，如果该类是针对第三方的，那么我总是会提供 == 或 != 。 == 和 != 运算符。如果该类仅供组内部使用，我仍然可能会实现 == 和 != 运算符，

我只会实现 <、<=、> 和 。 >= 运算符（如果实现了 IComparable）。仅当类型需要支持排序时才应实现 IComparable - 例如在排序或在有序通用容器（如 SortedSet）中使用时，

如果组或公司制定了不实现的策略 。 == 和 != 运算符 - 那么我当然会遵循该策略，如果存在这样的策略，那么明智的做法是使用标记 == 和 的任何出现的 Q/A 代码分析工具来强制执行它。 != 运算符与引用类型一起使用。

Answer 5

那篇文章只是建议不要重写相等运算符（对于引用类型），而不是反对重写 Equals。 如果相等检查不仅仅意味着引用检查，那么您应该在对象（引用或值）中覆盖 Equals。 如果您想要一个接口，您还可以实现 IEquatable （由通用集合）。 但是，如果您确实实现了 IEquatable，则还应该覆盖 equals，如 IEquatable 备注部分所述：

如果实现 IEquatable，还应该重写 Object.Equals(Object) 和 GetHashCode 的基类实现，以便它们的行为与 IEquatable.Equals 方法的行为一致。 如果您确实重写了 Object.Equals(Object)，则在调用类上的静态 Equals(System.Object, System.Object) 方法时也会调用您的重写实现。 这可确保 Equals 方法的所有调用返回一致的结果。

关于是否应该实现 Equals 和/或相等运算符：

来自 实现等于方法

大多数引用类型不应重载相等运算符，即使它们覆盖 Equals。

来自 实现等于和等于运算符 (==) 的指南

每当您实现相等运算符 (==) 时，请重写 Equals 方法，并使它们执行相同的操作。

这只是说，每当您实现相等运算符时，您都需要覆盖 Equals。 它确实没有表明您在重写Equals 时需要重写相等运算符。

Answer 6

对于将产生特定比较的复杂对象，那么实现 IComparable 并在 Compare 方法中定义比较是一个很好的实现。

例如，我们有“车辆”对象，其中唯一的区别可能是注册号，我们使用它进行比较以确保测试中返回的预期值是我们想要的值。

Answer 7

我倾向于使用 Resharper 自动制作的东西。 例如，它为我的一种引用类型自动创建了这个：

public override bool Equals(object obj)
{
    if (ReferenceEquals(null, obj)) return false;
    if (ReferenceEquals(this, obj)) return true;
    return obj.GetType() == typeof(SecurableResourcePermission) && Equals((SecurableResourcePermission)obj);
}

public bool Equals(SecurableResourcePermission obj)
{
    if (ReferenceEquals(null, obj)) return false;
    if (ReferenceEquals(this, obj)) return true;
    return obj.ResourceUid == ResourceUid && Equals(obj.ActionCode, ActionCode) && Equals(obj.AllowDeny, AllowDeny);
}

public override int GetHashCode()
{
    unchecked
    {
        int result = (int)ResourceUid;
        result = (result * 397) ^ (ActionCode != null ? ActionCode.GetHashCode() : 0);
        result = (result * 397) ^ AllowDeny.GetHashCode();
        return result;
    }
}

如果您想覆盖 == 并仍然进行引用检查，您仍然可以使用 Object.ReferenceEquals。

Answer 8

我相信，对于 .NET 的设计来说，像检查对象是否相等这样简单的事情有点棘手。

对于结构

1) 实现IEquatable。 它显着提高了性能。

2) 由于您现在拥有自己的 Equals，请重写 GetHashCode，并与各种相等性检查重写 object.Equals 保持一致。

3) 重载 == 和 != 运算符不需要虔诚地完成，因为如果您无意中使用 == 或 !=，但这样做最好与 Equals 方法保持一致。

public struct Entity : IEquatable<Entity>
{
    public bool Equals(Entity other)
    {
        throw new NotImplementedException("Your equality check here...");
    }

    public override bool Equals(object obj)
    {
        if (obj == null || !(obj is Entity))
            return false;

        return Equals((Entity)obj);
    }

    public static bool operator ==(Entity e1, Entity e2)
    {
        return e1.Equals(e2);
    }

    public static bool operator !=(Entity e1, Entity e2)
    {
        return !(e1 == e2);
    }

    public override int GetHashCode()
    {
        throw new NotImplementedException("Your lightweight hashing algorithm, consistent with Equals method, here...");
    }
}

对于班级

来自 MS：

大多数引用类型不应重载相等运算符，即使它们覆盖 Equals。

对我来说， == 感觉就像值相等，更像是 Equals 方法的语法糖。 编写a == b比编写a.Equals(b)直观得多。 我们很少需要检查引用相等性。 在处理物理对象的逻辑表示的抽象级别中，这不是我们需要检查的内容。 我认为 == 和 Equals 具有不同的语义实际上可能会令人困惑。 我相信首先应该是 == 表示值相等，而 Equals 表示引用（或更好的名称，如 IsSameAs）。 我不想在这里认真对待 MS 指南，不仅因为它对我来说不自然，而且还因为重载 == 不会造成任何重大伤害。这与不覆盖非泛型 Equals 或 GetHashCode 不同，后者可能会反噬，因为框架不会在任何地方使用 ==，除非我们自己使用用它。 我从不重载 == 和 != 中获得的唯一真正好处是与整个框架设计的一致性，而我没有控制。 这确实是一件大事，所以遗憾的是我会坚持下去。

使用引用语义（可变对象）

1) 覆盖 Equals 和 GetHashCode。

2) 实现 IEquatable 不是必须的，但如果你有一个那就太好了。

public class Entity : IEquatable<Entity>
{
    public bool Equals(Entity other)
    {
        if (ReferenceEquals(this, other))
            return true;

        if (ReferenceEquals(null, other))
            return false;

        //if your below implementation will involve objects of derived classes, then do a 
        //GetType == other.GetType comparison
        throw new NotImplementedException("Your equality check here...");
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as Entity);
    }

    public override int GetHashCode()
    {
        throw new NotImplementedException("Your lightweight hashing algorithm, consistent with Equals method, here...");
    }
}

具有值语义（不可变对象）

这是棘手的部分。 如果不小心，很容易搞砸。

1) 覆盖 Equals 和 GetHashCode。

2) 重载 == 和 != 以匹配 Equals。 确保它适用于 null。

2) 实现 IEquatable 不是必须的，但如果你有一个那就太好了。

public class Entity : IEquatable<Entity>
{
    public bool Equals(Entity other)
    {
        if (ReferenceEquals(this, other))
            return true;

        if (ReferenceEquals(null, other))
            return false;

        //if your below implementation will involve objects of derived classes, then do a 
        //GetType == other.GetType comparison
        throw new NotImplementedException("Your equality check here...");
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as Entity);
    }

    public static bool operator ==(Entity e1, Entity e2)
    {
        if (ReferenceEquals(e1, null))
            return ReferenceEquals(e2, null);

        return e1.Equals(e2);
    }

    public static bool operator !=(Entity e1, Entity e2)
    {
        return !(e1 == e2);
    }

    public override int GetHashCode()
    {
        throw new NotImplementedException("Your lightweight hashing algorithm, consistent with Equals method, here...");
    }
}

要特别注意如果您的类可以继承，情况会如何，在这种情况下，您必须确定基类对象是否可以等于派生类对象。 理想情况下，如果没有派生类的对象用于相等性检查，则基类实例可以等于派生类实例，在这种情况下，不需要检查泛型 Type 相等性。 code>Equals 基类。

一般来说，请注意不要重复代码。 我本可以制作一个通用抽象基类（IEqualized 左右）作为模板，以便更轻松地重用，但遗憾的是在 C# 中，这阻止了我从其他类派生。

Answer 9

我在这个

例子中使用 IEqualityComparer 或 IEquatable：

产品实体：

public class Product : IEquatable<Product>
{
    [Key]
    public int ID { get; set; }

    [Required]
    [MaxLength(50)]
    public string Name { get; set; }

    [Required]
    [MaxLength(50)]
    public string SKU { get; set; }

    [Required]
    [MaxLength(100)]
    public string Description { get; set; }

    [MaxLength(100)]
    public string? ImageKey { get; set; }

    [Precision(18, 2)]
    public decimal UnitPrice { get; set; }

    public static bool operator == (Product? x, Product? y) => x.Equals(y);
    public static bool operator != (Product? x, Product? y) => !x.Equals(y);
    public override int GetHashCode() => new EqualityComparer().GetHashCode(this);
    public bool Equals(Product? other) => new EqualityComparer().Equals(this, other);
    public override bool Equals(object? obj) => new EqualityComparer().Equals(this, obj as Product);
}

产品的平等比较器

public class EqualityComparer : IEqualityComparer<Product>
{
    public bool Equals(Product? x, Product? y)
    {
        if (x is null || y is null) return false;
        if (x.ID <= 0 || y.ID <= 0) return false;
        return x.ID == y.ID;
    }
    public int GetHashCode([DisallowNull] Product obj)
    {
        unchecked
        {
            return (17 * 23) + obj.ID.GetHashCode();
        }
    }
}

通过 LinQ 使用此功能，

products.Where(x => orderedProducts.Contains(x, new EqualityComparer())).ToList()

products.Any(orderedProduct.Equals)

您也可以使用重载运算符，例如：

foreach (var orderedProduct in orderedProducts)
{
     foreach (var product in products)
     {
          if (product == orderedProduct)
          {
              var neededProduct = product 
          }
      }
 }

这可以是使用更干净的方式实现：

foreach (var orderedProduct in orderedProducts)
{
     var neededProduct = products.First(orderedProduct.Equals);
}

Answer 10

上面的所有答案都不考虑多态性，通常您希望派生引用使用派生的 Equals，即使通过基本引用进行比较也是如此。 请在此处查看问题/讨论/答案 - 平等和多态性