Question

我有一些包含多个字段的类。我需要按值比较它们，即如果它们的字段包含相同的数据，则类的两个实例是相等的。我为此重复了GetHashCode和Equals方法。

可能会发生这些类包含循环引用。

示例：我们想建立机构（如政府，体育俱乐部等）。一个机构有一个名字。 Club是一个具有名称和成员列表的机构。每个成员都是Person，其中包含姓名和最喜欢的机构。如果某个俱乐部的成员将该俱乐部作为他最喜欢的机构，我们会有一个循环参考。

但循环引用与值相等一起导致无限递归。这是一个代码示例：

interface IInstitution { string Name { get; } }

class Club : IInstitution
{
    public string Name { get; set; }
    public HashSet<Person> Members { get; set; }

    public override int GetHashCode() { return Name.GetHashCode() + Members.Count; }

    public override bool Equals(object obj)
    {
        Club other = obj as Club;
        if (other == null)
            return false;

        return Name.Equals(other.Name) && Members.SetEquals(other.Members);
    }
}

class Person
{
    public string Name { get; set; }
    public IInstitution FavouriteInstitution { get; set; }

    public override int GetHashCode() { return Name.GetHashCode(); }

    public override bool Equals(object obj)
    {
        Person other = obj as Person;
        if (other == null)
            return false;

        return Name.Equals(other.Name)
            && FavouriteInstitution.Equals(other.FavouriteInstitution);
    }
}

class Program
{
    public static void Main()
    {
        Club c1 = new Club { Name = "myClub", Members = new HashSet<Person>() };
        Person p1 = new Person { Name = "Johnny", FavouriteInstitution = c1 }
        c1.Members.Add(p1);

        Club c2 = new Club { Name = "myClub", Members = new HashSet<Person>() };
        Person p2 = new Person { Name = "Johnny", FavouriteInstitution = c2 }
        c2.Members.Add(p2);

        bool c1_and_c2_equal = c1.Equals(c2); // StackOverflowException!
            // c1.Equals(c2) calls Members.SetEquals(other.Members)
            // Members.SetEquals(other.Members) calls p1.Equals(p2)
            // p1.Equals(p2) calls c1.Equals(c2) 
    }
}

c1_and_c2_equal应该返回true，事实上我们（人类）可以通过一点思考看到它们的价值相等，而不会遇到无限递归。但是，我无法真实地说出我们如何解决这个问题。但既然有可能，我希望有一种方法可以在代码中解决这个问题！

所以问题是：如何在不进行无限递归的情况下检查值的相等性？

请注意，我需要解决一般的循环引用，而不仅仅是上面的情况。我将其称为2圈，因为c1引用p1，p1引用c1。可以存在其他n圆，例如如果某个俱乐部A有一名成员M，其中最喜欢的是俱乐部B，其成员N最喜欢的俱乐部是A。这将是一个4圈。其他对象模型也可能允许具有奇数n的n个圆。我正在寻找一种方法来解决所有这些问题，因为我事先不知道n可以有哪些价值。

Answer 1

一个简单的解决方法（在RDBMS中使用）是使用唯一的Id来标识Person（任何类型）。然后你不需要比较所有其他财产，你也不会遇到这样的参考。

另一种方法是在Equals中进行不同的比较，因此仅对Equals的类型进行深度检查，而不对引用的类型进行深度检查。您可以使用自定义比较器：

public class PersonNameComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        if (x == null && y == null) return true;
        if (x == null || y == null) return false;
        if(object.ReferenceEquals(x, y)) return true;
        return x.Name == y.Name;
    }

    public int GetHashCode(Person obj)
    {
        return obj?.Name?.GetHashCode() ?? int.MinValue;
    }
}

现在，您可以更改Equals Club的{{1}}实施，以避免Members（人）使用包含该机构的深层检查，但仅限Name：

public override bool Equals(object obj)
{
    if (Object.ReferenceEquals(this, obj))
        return true;

    Club other = obj as Club;
    if (other == null)
        return false;

    var personNameComparer = new PersonNameComparer();
    return Name.Equals(other.Name) 
        && Members.Count == other.Members.Count 
        && !Members.Except(other.Members, personNameComparer).Any();
}

您注意到我无法使用SetEquals，因为我的自定义比较器没有过载。

Answer 2

根据Dryadwoods的建议，我更改了Equals方法，以便我可以跟踪已经比较的项目。

首先，我们需要一个相等比较器来检查对的相应元素的引用相等性：

public class ValuePairRefEqualityComparer<T> : IEqualityComparer<(T,T)> where T : class
{
    public static ValuePairRefEqualityComparer<T> Instance
        = new ValuePairRefEqualityComparer<T>();
    private ValuePairRefEqualityComparer() { }

    public bool Equals((T,T) x, (T,T) y)
    {
        return ReferenceEquals(x.Item1, y.Item1)
            && ReferenceEquals(x.Item2, y.Item2);
    }

    public int GetHashCode((T,T) obj)
    {
        return RuntimeHelpers.GetHashCode(obj.Item1)
            + 2 * RuntimeHelpers.GetHashCode(obj.Item2);
    }
}

以下是Equals修改后的Club方法：

static HashSet<(Club,Club)> checkedPairs
    = new HashSet<(Club,Club)>(ValuePairRefEqualityComparer<Club>.Instance);

public override bool Equals(object obj)
{
    Club other = obj as Club;
    if (other == null)
        return false;

    if (!Name.Equals(other.Name))
        return;

    if (checkedPairs.Contains((this,other)) || checkedPairs.Contains((other,this)))
        return true;

    checkedPairs.Add((this,other));

    bool membersEqual = Members.SetEquals(other.Members);
    checkedPairs.Clear();
    return membersEqual;
}

Person的版本类似。请注意，我将(this,other)添加到checkedPairs并检查是否包含(this,other)或(other,this)，因为在第一次调用c1.Equals(c2)之后可能会发生这种情况，我们结束了拨打c2.Equals(c1)而不是c1.Equals(c2)。我不确定这是否真的发生了，但由于我看不到SetEquals的实现，我相信这是可能的。

由于我对使用已经检查的对的静态字段不满意（如果程序是并发的，它将不起作用！），我问了另一个问题：make a variable last for a call stack。

Answer 3

对于我感兴趣的一般情况

- 我们的课程C1，...，Cn，其中每个类都可以包含任意数量的VALUES（例如int，string ,. ..）以及C1，...，Cn的任何其他类的任意数量的引用（例如，通过为每个类型Ci创建一个字段ICollection<Ci>） -

问题＆＃34;两个对象A和B是否相等？＆＃34; ，在我所描述的平等意义上，

似乎等同于

问题＆＃34;对于两个有限的，定向的，连通的，有色的图G和H，是否存在从G到{{1}的同构}＆＃34;

这是等价：

图形顶点对应于H s（类实例）

图形边缘对应于object s
的引用
颜色对应于值的集合和类型本身（即，如果相应的object具有相同的类型和相同的值，则两个顶点的颜色相同）

这是一个NP难题，所以我想我会放弃实施此计划的计划，而是采用循环无参考方法。

值等于和循环引用：如何解决无限递归？

3 个答案: