What's the relation between GetHashCode and Equals in a IEqualityComparer implementation?

Question

I have a class A that inherits from a class B and implements IEqualityComparer<A>. This means class A provides its own implementation of both Equals and GetHashCode methods. So far so good. The problem is that I don't understand why the code behaves in the following way:

debugger will only reach A's Equals implementation breakpoint if A's GetHashCode implementation returns this.GetHashCode() instead of obj.GetHashCode(), with "obj" being the parameter that GetHashCode's signature defines(a variable of type A, in my case).

Intuitively, I thought that I should return the hashcode of the object I received, but doing so makes the compiler ignore the instance's Equals implementation.

Why does this happen?

Code demonstration:

public class A : B, IEqualityComparer<A>
{
    public bool Equals(A x, A y)
    {
        //my implementation...
    }

    public int GetHashCode(A obj)
    {
        //return obj.GetHashCode(); -> this makes my Equals implementation above be ignored! Why?
        return this.GetHashCode(); -> my Equals implementation is used
    }
}

Can you post some code explaining the problem, it is hard to guess it right — Sriram Sakthivel, Apr 08 '14 at 07:52

Jodrell · Answer 1 · 2014-04-08T09:01:50.810

Implementing IEqualityComparer<T> doesn't override the base implementation of GetHashCode and Equals.

Implementing IEqualityComparer<T> allows you to supply an instance of the implementor as an equality comparer for T. This is a common parameter to several linq extensions and generic collection constructors.

Overriding Equals and GetHashCode effects the way instances of a class are tested for equality. Tapping into other implmentations that call Equals and GetHashCode, like the base = and != operators and linq extensions and generic collection constructors where you don't supply an alternative IEqualityComparer<T>.

These concepts are similar but serve different purposes, they are not partially interchangable.

Let me expand with an example,

public class A
{
    public string Value1 { get; set; }
    public int Value2 { get; set; }

    public override int GetHashCode()
    {
        unchecked
        {
            int hash = 17;
            hash = (hash * 23) + 
                StringComparer.Ordinal.GetHashCode(this.Value1);
            hash = (hash * 23) + this.Value2;
            return hash;
        }
    }

    public override bool Equals(object obj)
    {
        var a = obj as A;
        if (a == null)
        {
            return false;
        }

        if (a.Value2 != this.Value2)
        {
            return false;
        }

        return StringComparer.Ordinal.Equals(
            a.Value1,
            this.Value1);
    }
}

This implementation of A correctly overrides Equals and GetHashCode, this change is sufficient to ensure that after calling the linq extension

var distinct = aSequneceOfA.Distinct();

distinct will not contain any instances that have both the same Value2 and ordinally comparable Value1. No other interface implementation is necessary to achieve this.

Now, suppose that in some situation I wasn't happy with this ordinal comparison for Value1, perhaps I require some case insensitivity. I might implement an new equality comparer.

public class AComparerInsensitive : IEqualityComparer<A>
{
    public bool Equals(A x, A y)
    {
        if (x == null)
        {
            return y == null;
        }

        if (y == null)
        {
            return false;
        }

        if (x.Value2 != y.Value2)
        {
            return false;
        }

        return StringComparer.CurrentCultureIgnoreCase.Equals(
            x.Value1,
            y.Value1)
    }

    public int GetHashCode(A a)
    {
        if (a == null)
        {
            return 0;
        }

        unchecked
        {
            int hash = 17;
            hash = (hash * 23) + 
                StringComparer.CurrentCultureIgnoreCase.GetHashCode(
                    a.Value1);
            hash = (hash * 23) + a.Value2;
            return hash;
        }
    }
}

This would allow me to call the alternative overload of Distinct,

var insensitivelyDistinct = aSequneceOfA.Distinct(
    new AComparerInsensitive());

This overload of distinct ingnores As overridden Equals and GetHashCode and uses AComparerInsensitive to perform the comparison.

@Veverke I hope my expanded answer makes things clearer. – Jodrell Apr 08 '14 at 09:04 — Jodrell, Apr 08 '14 at 09:04

Jeppe Stig Nielsen · Answer 2 · 2014-04-08T08:05:08.893

1

It sounds like you are using the wrong interface. IEqualityComparer<> is typically used for a class that compares instances of other types.

Your type should simply implement IEquatable<A> and override Equals(object) and GetHashCode(). Note the signatures.

Like this:

public class A : B, IEquatable<A>
{
    public bool Equals(A other)
    {
       if (other == null || GetType() != other.GetType())
           return false;

       //your implementation
    }

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

    public override int GetHashCode()
    {
        //your implementation
    }
}

Then you can do stuff like someEnumerableOfA.Distinct() and the Linq method will use your implementation.

The other option is to do:

public class A : B // no interfaces
{
}

public class AEqualComparer : IEqualityComparer<A>
{
    public bool Equals(A x, A y)
    {
       //your implementation
    }

    public int GetHashCode(A x)
    {
        //your implementation
    }
}

With this other option you need someEnumerableOfA.Distinct(new AEqualComparer ()).

edited Apr 08 '14 at 08:05

answered Apr 08 '14 at 07:56

Jeppe Stig Nielsen

60,409
11
110
181

The reason I chose IEqualityComparer is because my solution relies in calling IEnumerable<>.Distinct<>(IEqualityComparer<>). In other words, if I want to return the distinct elements of my collection, why can I not use Distinct here and thus be required to provide a IEqualityComparer implementation? – Veverke Apr 08 '14 at 08:00
OP implements right interface but in wrong way. For more info refer the linked duplicate thread. – Sriram Sakthivel Apr 08 '14 at 08:02
@Veverke, if you override `Equals` and `GetHashCode`, you won't need to implement or supply `IEqualityComparer`. – Jodrell Apr 08 '14 at 08:07
1

@SriramSakthivel Disagree. You shouldn't have a class `A` implement `IEqualityComparer`. That is misuse. Look at `String` class. It implements `IEquatable`. However, there are other classes, like `StringComparer` which implement `IEqualityComparer` (but **not** `IEqualityComparer`). – Jeppe Stig Nielsen Apr 08 '14 at 08:08
@Jodrell: And how will my IEnumerable call to Distinct be ? variable.Distinct(this) - where the current class overrides Equals and GetHashCode? – Veverke Apr 08 '14 at 08:11
@JeppeStigNielsen I know that; you're right on the money, that is misusing the interface, but that **should not** cause any problem, since signature is different. as you said there should be a comparer class dedicated doing just comparison. – Sriram Sakthivel Apr 08 '14 at 08:12
@Jodrell: remark: doing so has the "downside" of having to cast "object" into my own type... – Veverke Apr 08 '14 at 08:19
@SriramSakthivel Exactly. It is like if I make a class `Car`, I may or may not choose to make a `Car` "intrinsically" equality-comparable to other `Car`s, for example checking if the registration plate numbers agree. But then I could make another `class ByColorCarEqualityComparer : IEqualityComparer` or `class ByBrandAndModelIDCarEqualityComparer : IEqualityComparer`. But to make a "car" whose purpose it is to compare "cars" by some criteria, is confusing. Cars are for driving in. They are something else than car comparers. – Jeppe Stig Nielsen Apr 08 '14 at 08:23
Again, I agree with you completely. My point is there is nothing wrong technically but it is a wrong design which makes confusion etc but.. It will work is what I say, and the suggested duplicate says why it doesn't work. – Sriram Sakthivel Apr 08 '14 at 08:27

What's the relation between GetHashCode and Equals in a IEqualityComparer implementation?

2 Answers2