.NET 域模型中的对象平等

Question

我正在寻找有关在域模型中实现平等时的最佳实践的建议。在我看来，存在三 (3) 种相等类型：

1. 引用相等 - 意味着两个对象存储在同一个对象中 物理内存空间。

2. 身份平等 - 意味着两个对象具有相同的身份值。 例如，两个具有相同订单号的订单对象 代表同一实体。这一点尤其重要 当在列表、哈希表等中存储值时 对象需要唯一的标识进行查找。

3. 值相等 - 两个对象的所有属性都相同。

按照惯例，.NET 提供了两 (2) 种测试相等性的方法：Equals 和 ==。那么我们如何将三 (3) 类型映射到两 (2) 方法呢？

当然，我遗漏了 Object.ReferenceEquals，MS 添加它是为了认识到大多数人都在重写 Equals，因为引用相等不是他们想要的行为。所以也许我们可以划掉第一种类型（？）。

考虑到 GetHashCode 和 Equals 在哈希表上下文中的行为，是否可以肯定地说 Equals 应该始终提供身份相等性？如果是这样，我们如何为调用者提供测试价值平等的方法？

而且，大多数开发人员不是都认为 Equals 和 == 会产生相同的结果吗？由于 == 测试引用相等性，这是否意味着我们在重写 Equals 时也应该重载 == ？

你的想法？

更新

我不知道所有细节，但我被告知（在与同事的面对面交谈中）WPF 对数据绑定对象对 Equals 或 data- 使用引用相等性有严格要求绑定无法正常工作。

此外，看看典型的 Assert 类，还有更令人困惑的语义。 AreEqual(a, b) 通常使用 Equals 方法来表示身份或值相等，而 AreSame(a, b) 使用 ReferenceEquals 来表示引用相等。

Answer 1

我通常开发域模型的方式是围绕执行引用相等的 == 和 ReferenceEquals() 。 Equals() 执行值相等。我不使用这些来实现身份相等的原因有三个：

并非所有东西都有身份，因此当涉及没有身份的对象时，会导致人们对 Equals() 和 == 的实际工作原理感到困惑。例如，考虑包含多个实体或临时/辅助对象的缓存。可能基于多个不同域对象的聚合对象又如何呢？它会比较哪个身份？

身份平等是价值平等的一个子集，从我的经验来看，只要涉及到身份平等，价值平等就紧随其后，通常价值身份也包含身份平等。毕竟，如果身份不一样，价值观真的一样吗？

身份平等本身到底意味着什么，问自己这个问题：“在没有上下文的情况下，身份平等意味着什么？” Id 1的用户是否等于Id 1的评论？我当然希望不会，因为这两个实体是非常不同的东西。

那么，为什么要对例外而不是规则的情况使用任何内置相等方法（== 和 Equals()）呢？相反，我倾向于实现一个基类，它提供我的身份信息，并根据我当前域中身份平等的常见程度来实现身份平等。

例如;在身份平等非常罕见的领域中，如果身份平等在我当前的领域中不是一个常见问题，我将创建一个自定义 EqualityComparer ，以便在需要时以上下文敏感的方式实现身份平等。

但是，在身份平等非常常见的领域中，我会选择身份基类中名为 IdentityEquals() 的方法，该方法负责处理基本级别上的身份平等。

这样我只在相关且合乎逻辑的地方公开身份平等。不会对我的任何平等检查如何工作产生任何潜在的困惑。无论是 Equals()、== 还是 IdentityEquals / EqualityComparer（取决于常见程度）身份平等属于我的领域）。

另外，作为旁注，我建议阅读 Microsoft 的 指南用于重载相等。

具体来说：

默认情况下，运算符 == 通过以下方式测试引用相等性：
判断两个引用是否指示同一个对象，因此引用
类型不需要实现运算符 == 来获得这个
功能。当类型是不可变的时，意味着包含在
实例无法更改，重载运算符 == 进行比较
值相等而不是引用相等可能很有用，因为
不可变对象，只要它们可以被认为是相同的
具有相同的值。 在非不可变类型中重写运算符 == 是
不推荐。

编辑：

关于 Assert.AreEqual 和 Assert.AreSame，您的域定义了平等的含义；无论是参考、身份还是价值。因此，通过扩展，域中 Equals 的定义也可以扩展到 Assert.AreEqual 的定义。如果您说 Equals 检查身份相等性，那么通过逻辑扩展 Assert.AreEqual 将验证身份相等性。

Assert.AreSame 检查两个对象是否是同一对象。相同和等于是两个不同的概念。检查 A 引用的对象与 B 引用的对象是否相同的唯一方法是引用相等。从语义和句法上看，这两个名字都有道理。

Answer 2

对于引用相等，我使用 object.ReferenceEquals 正如你所说，尽管你也可以将引用强制转换为对象并比较它们（只要它们是引用类型）。

对于 2 和 3，这实际上取决于开发人员想要什么，他们是否想将平等定义为身份平等或价值平等。通常，我喜欢将 Equals() 保留为值相等，然后提供外部比较器以实现身份相等。

大多数比较项目的方法都使您能够传递自定义比较器，这就是我通常传递任何自定义相等比较器（如身份）的地方，但这就是我。

正如我所说，这是我的典型用法，我还构建了对象模型，其中我只考虑属性的子集来表示身份，并且不比较其他属性。

您始终可以创建一个非常简单的 ProjectionComparer，它采用任何类型并基于投影创建比较器，使得在需要时非常容易地传递用于身份等的自定义比较器，并将 Equals() 方法仅用于值。

另外，通常情况下，我个人不会重载 == ，除非我正在编写需要典型比较运算符的值类型，因为运算符重载以及重载如何不被覆盖存在很多混乱。

但这只是我的意见:-)

更新这是我的投影比较器，当然，您可以找到许多其他实现，但这一个对我来说效果很好，它实现了 EqualityComparer; （支持 bool Equals(T, T) 和 int GetHashCode(T) 和IComparer 支持Compare(T, T))：

public sealed class ProjectionComparer<TCompare, TProjected> : EqualityComparer<TCompare>, IComparer<TCompare>
{
    private readonly Func<TCompare, TProjected> _projection;

            // construct with the projection
    public ProjectionComparer(Func<TCompare, TProjected> projection)
    {
        if (projection == null)
        {
            throw new ArgumentNullException("projection");
        }

        _projection = projection;
    }

    // Compares objects, if either object is null, use standard null rules
            // for compare, then compare projection of each if both not null.
    public int Compare(TCompare left, TCompare right)
    {
        // if both same object or both null, return zero automatically
        if (ReferenceEquals(left, right))
        {
            return 0;
        }

        // can only happen if left null and right not null
        if (left == null)
        {
            return -1;
        }

        // can only happen if right null and left non-null
        if (right == null)
        {
            return 1;
        }

        // otherwise compare the projections
        return Comparer<TProjected>.Default.Compare(_projection(left), _projection(right));
    }

    // Equals method that checks for null objects and then checks projection
    public override bool Equals(TCompare left, TCompare right)
    {
        // why bother to extract if they refer to same object...
        if (ReferenceEquals(left, right))
        {
            return true;
        }

        // if either is null, no sense checking either (both are null is handled by ReferenceEquals())
        if (left == null || right == null)
        {
            return false;
        }

        return Equals(_projection(left), _projection(right));
    }

    // GetHashCode method that gets hash code of the projection result
    public override int GetHashCode(TCompare obj)
    {
        // unlike Equals, GetHashCode() should never be called on a null object
        if (obj == null)
        {
            throw new ArgumentNullException("obj");
        }

        var key = _projection(obj);

        // I decided since obj is non-null, i'd return zero if key was null.
        return key == null ? 0 : key.GetHashCode();
    }

    // Factory method to generate the comparer for the projection using type
    public static ProjectionComparer<TCompare, TProjected> Create<TCompare, 
                     TProjected>(Func<TCompare, TProjected> projection)
    {
        return new ProjectionComparer<TCompare, TProjected>(projection);
    }
}

这可以让您执行以下操作：

List<Employee> emp = ...;

// sort by ID
emp.Sort(ProjectionComparer.Create((Employee e) => e.ID));

// sort by name
emp.Sort(ProjectionComparer.Create((Employee e) => e.Name));

Answer 3

我想我应该从上述帖子以及外部对话中提出我的总结作为答案，而不是通过更新原始帖子来混淆主题。我将保留该主题，让读者投票选择他们认为最好的答案，然后再选择一个。

以下是我从这些讨论中收集到的要点：

1. 实体在域模型中的定义具有标识。

2. 聚合根是（根据我读过的定义）包含其他实体的实体；因此，聚合也具有身份。

3. 虽然实体是可变的，但它们的身份不应该是。

4. Microsoft 指南指出，当两个对象的 GetHashCode() 相等时，Equals 应为这些对象返回 true。

5. 当在哈希表中存储实体时，GetHashCode 应返回一个表示该实体身份的值。

6. 身份平等并不意味着参照平等或价值平等。价值平等也不意味着参照平等。但是，参照平等确实意味着身份和价值平等。

说实话，我逐渐意识到这可能只是一个语法/语义问题。我们需要第三种定义平等的方式。我们有两个：

等于。在域模型中，当两个实体共享相同的身份时，它们相等。我觉得为了满足#4和#4，情况必须如此。上面#5。我们使用实体的身份来生成从 GetHashCode 返回的哈希码，因此必须使用相同的值来确定相等性。

相同。根据现有用法（在调试和测试框架中），当两个对象/实体相同时，它们引用相同的实例（引用相等）。

<强>???。那么我们如何在代码中表示值相等呢？

在我所有的谈话中，我发现我们正在以某种方式应用限定词来塑造这些术语；使用“IdentityEquals”和“IsSameXYZ”等名称，因此“Equals”表示值相等，或使用“IsEquivalentTo”和“ExactlyEquals”表示值相等，因此“Equals”表示身份相等。

虽然我欣赏灵活性，但沿着这条路走得越多，我就越意识到没有两个开发人员会以相同的方式看待这一点。这会导致问题。

我可以告诉你，我采访过的每一位开发人员都表示，他们希望“==”的行为与 Equals 完全相同。然而，即使我们覆盖 Equals，Microsoft 建议也不要重载“==”。如果核心 == 运算符能够简单地委托给 Equals，那就太好了。

因此，最重要的是，我将重写 Equals 以提供身份平等，为引用平等提供 SameAs 方法（只是 ReferenceEquals 的方便包装），并在我们的基类中重载 == 以使用 Equals，以便它们保持一致。然后，我将使用比较器来“比较”两个“相等”实体的值。

更多想法？