Equality, GetHashCode and hashed collections

C# has two questions that sound alike: are these the same object? (reference equality) and do these hold the same value? (value equality). Which one == and Equals answer depends on the type.

• For a class that overrides nothing, both == and Equals compare references. Two new Point(1, 2) objects are different objects, so they are not equal.
• string overloads == and overrides Equals to compare characters.
• Operators are chosen at compile time from the static type. Cast two strings to object and == becomes the reference comparison on object, while Equals, a virtual method, still runs the string version.

1public class Point2{3    public int X, Y;4    public Point(int x, int y) { X = x; Y = y; }5}6 7public static class Solution8{9    public static string Describe()10    {11        var p1 = new Point(1, 2);12        var p2 = new Point(1, 2);13 14        string a = "hello";15        string b = new string(new[] { 'h', 'e', 'l', 'l', 'o' });16        object oa = a, ob = b;17 18        return $"points: =={p1 == p2} Equals={p1.Equals(p2)} | " +19               $"strings: =={a == b} object=={oa == ob} Equals={oa.Equals(ob)}";20    }21}

The string b is built at runtime from a char array, so it is a different object from the literal a even though the characters match. That is why object== says False.

Equals and GetHashCode are a pair

HashSet<T> and Dictionary<TKey, TValue> do not compare every element. They compute GetHashCode(), jump to the bucket for that number, and only then call Equals on the few items in it. The contract that makes this work: if two objects are equal, their hash codes must be equal. (The reverse need not hold; collisions are fine.)

public sealed class Isbn : IEquatable<Isbn>
{
    private readonly string _digits;
    public Isbn(string text) => _digits = text.Replace("-", "");

    public bool Equals(Isbn? other) => other is not null && _digits == other._digits;
    public override bool Equals(object? obj) => Equals(obj as Isbn);
    public override int GetHashCode() => _digits.GetHashCode();
}

Hash the same normalised data you compare. Implementing IEquatable<T> gives collections a typed Equals to call, which avoids a cast (and, for structs, boxing).

When you cannot change the type, or need a different notion of equality for one collection, pass a comparer instead: new HashSet<string>(StringComparer.OrdinalIgnoreCase) treats "Ab" and "aB" as one element.

Common mistakes

1public class HalfDone2{3    public string Code;4    public HalfDone(string code) => Code = code;5    public override bool Equals(object? obj) => obj is HalfDone o && o.Code == Code;6    // GetHashCode deliberately NOT overridden7}8 9public class Done10{11    public string Code;12    public Done(string code) => Code = code;13    public override bool Equals(object? obj) => obj is Done o && o.Code == Code;14    public override int GetHashCode() => Code.GetHashCode();15}16 17public static class Solution18{19    public static string Describe()20    {21        var half = new HashSet<HalfDone> { new HalfDone("A1"), new HalfDone("A1") };22        var done = new HashSet<Done> { new Done("A1"), new Done("A1") };23 24        var key = new Done("B2");25        var set = new HashSet<Done> { key };26        key.Code = "B3";   // mutate a key that is already inside the set27 28        return $"without GetHashCode: {half.Count} | with: {done.Count} | " +29               $"after mutating key: Contains(same object)={set.Contains(key)}";30    }31}

• Overriding Equals but not GetHashCode. HalfDone says two "A1" objects are equal, but each inherits a per-object hash code, so the set files them in different buckets and keeps both. The compiler warns (CS0659); treat that warning as an error.
• Mutating a key after inserting it. The set stored key in the bucket for "B2". After Code changes, a lookup hashes "B3", searches the wrong bucket, and Contains returns False for the very object that is inside. Make key fields read-only.
• Using == on values typed as object. That compares references, so two boxed 42s are not ==. Use Equals, or pattern-match back to the real type first.

What interviewers ask

• "What is the difference between == and Equals?" == is an operator resolved at compile time from the static types; is virtual and resolved from the runtime type. For classes both default to reference equality unless overridden.