具有相同元素的两个列表不相等。为什么？

Question

我有以下几点：

  var a = new List<OrderRule> {
    new OrderRule("name", OrderDirection.Ascending),
    new OrderRule("age", OrderDirection.Descending)
  };


  var b = new List<OrderRule> {
    new OrderRule("name", OrderDirection.Ascending),
    new OrderRule("age", OrderDirection.Descending)
  };

  var r = a.Equals(b);

即使两个列表包含彼此相等的项目，r 变量也是假的。 OrdeRule 类实现了 IEquality。请注意，当 Direction 和 Property 都相等时，两个 OrderRules 相等。

public enum OrderDirection { ASC, DESC }

public class OrderRule : IEquatable<OrderRule> {

  public OrderDirection Direction { get; }
  public String Property { get; }

  public OrderRule(String property, OrderDirection direction) {
    Direction = direction;
    Property = property;
  }

  public Boolean Equals(OrderRule other) {

    if (other == null)
      return false;

    return Property.Equals(other.Property) && Direction.Equals(other.Direction);

  }

  public override Boolean Equals(Object obj) {

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

    if (ReferenceEquals(this, obj))
      return true;

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

    return Equals(obj as IncludeRule);

  }

  public override Int32 GetHashCode() {

    return HashCode.Of(Property).And(Direction);

  }

}

我错过了什么？

Answer 1

---

检查两个列表是否相等并不意味着检查它们是否都包含相同的项目。

如果你这样做：

var a = new List<OrderRule>();
var b = new List<OrderRule>();
var r = a.Equals(b); //false

r 将始终为 false，即使两个列表中包含相同的项目。那是因为您没有检查列表的内容。您实际上是在检查 a 和 b 是否都引用同一个对象。但是a 是一个对象，b 是另一个对象。

如果你这样做了，r 将是真的：

var a = new List<OrderRule>();
var b = a;
var r = a.Equals(b) //true

如果您有两个列表，并且您想查看它们是否以相同的顺序包含相同的项目，您可以这样做：

var r = a.SequenceEquals(b);

在您的问题示例中，r 将是 true，因为您在 OrderRule 上覆盖了Equals，因此一个列表中的项目被认为与另一个列表中的项目“相等”。

---

知道了 - 你在 OrderRule 中的平等检查被破坏了。

public override Boolean Equals(Object obj) {
if (ReferenceEquals(null, obj))
  return false;

if (ReferenceEquals(this, obj))
  return true;

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

return Equals(obj as IncludeRule);
}

我认为你的意思不是return Equals(obj as IncludeRule)，而是return Equals(obj as OrderRule)。

Answer 2

您的代码正在测试它们是否是同一个列表。如果它们的内容相同，则不会。

a.Equals(b); // false
var d = a;
d.Equals(a); // true

如果要比较内容，请使用 linq 的 SequenceEqual

https://msdn.microsoft.com/en-us/library/bb348567(v=vs.100).aspx

Answer 3

首先，每当使用new 关键字或创建新对象时，对象的引用或地址都存储在变量中。 也等于比较变量的值。

现在您已经覆盖了OrderRule 的equals 函数。因此，如果您对两个 OrderRule 执行 equals 操作，您将在覆盖的 equals 函数中进行比较时得到结果。

但现在想想List<OrderRule> 是什么，它不过是一个泛型类。因此，equals 将再次检查包含引用的变量的值，并且由于它们不同，因此在比较它们时不会得到正确的结果。 List 也实现了与未被覆盖的对象相同的等号。因此，我更喜欢的一种方法是创建扩展。

public static class Extensions
{
    public static bool Equal<T>(this List<T> x, List<T> y)
    {
        bool isEqual = true;
        if (x == null ^ y == null)
        {
            isEqual = false;
        }
        else if (x == null && y == null)
        {
            isEqual = true;
        }
        else if (x.Equals(y))
        {
            isEqual = true;
        }
        else if (x.Count != y.Count)
        {
            isEqual = false;
        }
        else
        {
            //This logic can be changed as per your need.
            //Here order of the list matters!
            //You can make one where order doesn't matter
            for (int i = 0; i < x.Count; i++)
            {
                if (!x[i].Equals(y[i]))
                {
                    break;
                }
            }

        }
        return isEqual;
    }
}

Answer 4

这样做是在比较引用而不是对象。所以你会返回不等式。