Every C# type derives from System.Object. What members does it give you? Then review a Customer class that overrides Equals to compare Email but does not override GetHashCode: what breaks, and how do you implement equality correctly (or use a record)?

1. The equality contract in full

Equals must be:

1. Reflexive: x.Equals(x) is true.
2. Symmetric: x.Equals(y) == y.Equals(x).
3. Transitive: if x.Equals(y) and y.Equals(z) then x.Equals(z).
4. Consistent: repeated calls return the same result while the objects do not change.
5. Null-safe: x.Equals(null) is false and never throws.

GetHashCode must:

• Return equal values for equal objects (the hard requirement).
• Stay stable while the object is in a hash-based collection.
• Ideally spread values uniformly across int to minimise collisions.
• Not be persisted or sent across processes — string hash codes are randomised per process in .NET Core (to resist hash-flooding attacks), so "abc".GetHashCode() differs between runs.

Unequal objects may share a hash code (collisions are allowed); equal objects must share one.

2. How Dictionary<TKey,TValue> uses them

1. Compute hash = comparer.GetHashCode(key).
2. Pick a bucket: hash % buckets.Length (with fast modulo via multiplication on 64-bit).
3. Walk the chain of entries in that bucket, comparing stored hash codes first, then calling comparer.Equals(entry.key, key) only when hashes match.

If two equal keys produce different hashes, they land in different buckets and Equals is never called — so overriding Equals alone does nothing for dictionaries. If GetHashCode returns a constant (return 1;), everything lands in one bucket and lookups degrade from O(1) to O(n).

3. Default implementations

• object.GetHashCode() for classes: an identity hash, generated on first call and stored in the object header (or the sync block if the header is already used by a lock). It never changes for the object's lifetime, regardless of field values.
• object.Equals: ReferenceEquals(this, obj).
• ValueType.Equals: field-by-field, using a fast bitwise compare when the struct has no references or padding, otherwise reflection.
• ValueType.GetHashCode: historically based on the first non-null field; may be poor. Always override for structs used as keys.

4. What records generate

For record Person(string Name, int Age) the compiler emits roughly:

protected virtual Type EqualityContract => typeof(Person);

public virtual bool Equals(Person? other) =>
    (object)this == other ||
    (other is not null && EqualityContract == other.EqualityContract &&
     EqualityComparer<string>.Default.Equals(Name, other.Name) &&
     EqualityComparer<int>.Default.Equals(Age, other.Age));

public override int GetHashCode() =>
    HashCode.Combine(EqualityContract, Name, Age);   // conceptually

EqualityContract ensures a derived record (Employee : Person) is never equal to a base Person with the same values — solving the symmetry problem that hand-written obj is Customer checks have. You can customise by writing your own Equals(Person? other) and GetHashCode in the record (for example to compare a list property with SequenceEqual).

5. HashCode.Combine and good hash functions

HashCode.Combine(a, b, c) (.NET Core 2.1+) uses xxHash32 with a per-process random seed, giving good distribution and resistance to collision attacks. Older patterns like hash = hash * 31 + field are fine but weaker. For strings with custom comparison, use the matching comparer's hash: StringComparer.OrdinalIgnoreCase.GetHashCode(s) — using s.ToLower().GetHashCode() allocates and can disagree with your Equals on culture edge cases.

6. Equality in EF Core and the identity map

EF Core's change tracker uses reference identity and key values to track entities. Overriding Equals/GetHashCode on entities with mutable properties (or with database-generated IDs that change from 0 to a real value after SaveChanges) can break collections of entities in navigation properties: an entity added to a HashSet<OrderLine> with hash based on Id = 0 is "lost" after the ID is assigned. Common guidance:

• Value objects (owned types, complex types in EF Core 8+): value equality.
• Entities: reference equality, or identity-based equality that only compares when IDs are assigned, with GetHashCode based on something immutable.

7. ToString and logging

Overriding ToString improves debugging and logs (the debugger shows it in watch windows; [DebuggerDisplay] is a non-invasive alternative). Records generate a ToString printing all public properties — including personal information such as emails or tax file numbers. Under the Privacy Act and APP 11, logging that data needlessly is a risk; override PrintMembers or ToString on records that contain personal data.

Try it yourself

1. Put two "equal" instances of the broken Customer into a HashSet and print the count.
2. Add the correct GetHashCode, then mutate Email of an object already in the set and try Contains.
3. Create record Person and record Employee : Person with the same values and compare them.
4. Print "abc".GetHashCode() in two separate runs.

namespace Types;

// Correct hand-written equality for a class keyed by email (case-insensitive)
public sealed class Customer : IEquatable<Customer>
{
    public Customer(string email, string name)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(email);
        Email = email.Trim();
        Name = name;
    }

    public string Email { get; }          // immutable key
    public string Name { get; set; }      // not part of equality

    public bool Equals(Customer? other) =>
        other is not null && StringComparer.OrdinalIgnoreCase.Equals(Email, other.Email);

    public override bool Equals(object? obj) => Equals(obj as Customer);

    public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(Email);

    public static bool operator ==(Customer? left, Customer? right) =>
        left is null ? right is null : left.Equals(right);

    public static bool operator !=(Customer? left, Customer? right) => !(left == right);

    public override string ToString() => $"Customer({Name})";   // no email in logs
}

// Value-like data: let the compiler generate everything
public sealed record Address(string Street, string Suburb, string State, string Postcode);

public static class EqualityDemo
{
    public static void Main()
    {
        var a = new Customer("[email protected]", "Ada");
        var b = new Customer("[email protected]", "Ada L.");

        var set = new HashSet<Customer> { a, b };
        Console.WriteLine(set.Count);                    // 1
        Console.WriteLine(a == b);                       // True
        Console.WriteLine(ReferenceEquals(a, b));        // False

        var home = new Address("1 George St", "Sydney", "NSW", "2000");
        Console.WriteLine(home == home with { });        // True: value equality
        Console.WriteLine(home);                         // Address { Street = ..., ... }
    }
}