How does bit shifting values in this GetHashCode method improve hashing?

Question

I found two data types with hash code methods in a code base I'm working on, which I don't fully understand why they were chosen:

public override int GetHashCode()
{
    return x.GetHashCode() ^ y.GetHashCode() << 2;
}

public override int GetHashCode()
{
    return x.GetHashCode() ^ y.GetHashCode() << 2 ^ z.GetHashCode() >> 2;
}

How does the bit shifting operation make these hash values any better?

Answer 1

Let's say you have a Point data structure represented by a x and y variable. Without the bit shifting the value of hash code for (1,0) would be 1 , and the hash code for (0,1) would also be 1 . Now do the same thing with the bit shifting, for (1,0) we get a hash code of 1 , but for (0,1) we now get a hash code of 4

What the bit shifting provides is if you have the same inputs but in a different order you want to get different hash codes, that way (1,0) and (0,1) don't end up falling in to the same hash bucket and degrading your hashset/dictionary performance.

Normally you would do a much larger offset than just left shifting twice. Bitshifting also causes data to get truncated if dealing with hash codes near Int32.MaxValue . Here is the pattern I normally use

public override int GetHashCode()
{
    unchecked
    {
        var hashCode = X;
        hashCode = (hashCode*397) ^ Y;
        hashCode = (hashCode*397) ^ Z;
        return hashCode;
    }
}

(this is the default implementation that comes with Resharper's "Insert Comparison Method" feature. To add more fields you just keep doing hashCode = (hashCode*397) ^ XXXXXXX )

By using * with unchecked instead of << any value that is larger than Int32.MaxValue just overflows without error.