为 linq groupby 编写自定义比较器

Question

同样，这个示例是我实际问题的一个非常简化的版本，涉及用于 linq 分组的自定义比较器。我做错了什么？

下面的代码产生下面的结果 (1.2, 0), (4.1, 0), (4.1, 0), (1.1, 0),

但是我期待以下，因为 1.1 和 1.2 相差

class Program
{
    static void Main(string[] args)
    {
        IEnumerable<Point> points = new List<Point> { 
            new Point(1.1, 0.0)
            , new Point(4.1, 0.0) 
            , new Point(1.2, 0.0)
            , new Point(4.1, 0.0)
        };

        foreach (var group in points.GroupBy(p => p, new PointComparer()))
        {
            foreach (var num in group)
                Console.Write(num.ToString() + ", ");

            Console.WriteLine();
        }

        Console.ReadLine();
    }
}

class PointComparer : IEqualityComparer<Point>
{
    public bool Equals(Point a, Point b)
    {
        return Math.Abs(a.X - b.X) < 1.0;
    }

    public int GetHashCode(Point point)
    {
        return point.X.GetHashCode()
            ^ point.Y.GetHashCode();
    }
}

class Point
{
    public double X;
    public double Y;

    public Point(double p1, double p2)
    {
        X = p1;
        Y = p2;
    }

    public override string ToString()
    {
        return "(" + X + ", " + Y + ")";
    }
}

Answer 1

使用相等比较器的分组算法（我认为是所有 LINQ 方法）总是首先比较哈希码，并且只有在两个哈希码相等时才执行 Equals。您可以看到，如果您在相等比较器中添加跟踪语句：

class PointComparer : IEqualityComparer<Point>
{
    public bool Equals(Point a, Point b)
    {
        Console.WriteLine("Equals: point {0} - point {1}", a, b);
        return Math.Abs(a.X - b.X) < 1.0;
    }

    public int GetHashCode(Point point)
    {
        Console.WriteLine("HashCode: {0}", point);
        return point.X.GetHashCode()
            ^ point.Y.GetHashCode();
    }
}

结果：

HashCode: (1.1, 0)
HashCode: (4.1, 0)
HashCode: (1.2, 0)
HashCode: (4.1, 0)
Equals: point (4.1, 0) - point (4.1, 0)
(1.1, 0), 
(4.1, 0), (4.1, 0), 
(1.2, 0), 

仅对哈希码相等的两个点Equals 执行。

现在您可以通过始终返回 0 作为哈希码来欺骗比较。如果你这样做，输出将是：

HashCode: (1.1, 0)
HashCode: (4.1, 0)
Equals: point (1.1, 0) - point (4.1, 0)
HashCode: (1.2, 0)
Equals: point (4.1, 0) - point (1.2, 0)
Equals: point (1.1, 0) - point (1.2, 0)
HashCode: (4.1, 0)
Equals: point (4.1, 0) - point (4.1, 0)
(1.1, 0), (1.2, 0), 
(4.1, 0), (4.1, 0), 

现在对于每对 Equals 都已执行，并且您已经完成了分组。

但是……

什么是“相等”？如果您再添加一个点(2.1, 0.0)，您想要一组中的哪些点？使用符号≈ 表示模糊相等，我们有 -

1.1 ≈ 1.2
1.2 ≈ 2.1

但是

1.1 !≈ 2.1

这意味着1.1 和2.1 永远不会在一个组中（他们的Equals 永远不会通过）并且这取决于点的顺序是1.1 还是@ 987654337@ 与1.2 分组。

所以你在这里是在一个滑坡上。通过邻近度聚类点绝非易事。你正在进入cluster analysis的领域。

Answer 2

不要忘记GetHashCode 的效果。期望GetHashCode 将始终为任何两个对象返回相同的值，因为每个Equals 将返回true。如果你未能达到预期，你会得到意想不到的结果。

具体来说，GroupBy 可能使用像哈希表这样的东西来允许它将项目组合在一起，而无需将每个项目与其他项目进行比较。如果GetHashCode 返回的值最终不会将两个对象放入哈希表的同一个桶中，它将假定它们不相等，并且永远不会尝试对它们调用Equals。

当您尝试找出GetHashCode 的正确实现时，您会发现，您尝试对对象进行分组的方式存在根本问题。如果您的点的 x 值为 1.0、1.6 和 2.2，您会期待什么？ 1.0 和 2.2 彼此相距太远，无法属于同一组，但 1.6 与其他两个点足够接近，应该与它们在同一组中。所以你的Equals 方法打破了Transitive 相等的属性：

只要 A = B 和 B = C，那么 A = C

如果您尝试进行集群分组，您将需要使用更不同的数据结构和算法。如果您只是想稍微标准化点的位置，您可以只说points.GroupBy(p => (int)p.X) 并完全避免使用相等比较器。