C# / .NET Kompendium PLEN
.NET / C# / C# — fundamenty języka

Jak porównywać instancje record i class w C

Domyślne zachowanie - zestawienie

public class OrderClass { public int Id { get; set; } public string CustomerName { get; set; } }
public record OrderRecord(int Id, string CustomerName);

var c1 = new OrderClass { Id = 1, CustomerName = "Jan" };
var c2 = new OrderClass { Id = 1, CustomerName = "Jan" };

var r1 = new OrderRecord(1, "Jan");
var r2 = new OrderRecord(1, "Jan");

// CLASS - porównanie referencji
Console.WriteLine(c1 == c2);         // false
Console.WriteLine(c1.Equals(c2));    // false
Console.WriteLine(ReferenceEquals(c1, c2)); // false

// RECORD - porównanie wartości
Console.WriteLine(r1 == r2);         // true
Console.WriteLine(r1.Equals(r2));    // true
Console.WriteLine(ReferenceEquals(r1, r2)); // false - to WCIĄŻ różne obiekty w pamięci!

Kluczowa obserwacja: ReferenceEquals zawsze sprawdza tożsamość obiektu w pamięci, niezależnie czy to class czy record - record nie zmienia tego, co się fizycznie dzieje w pamięci, tylko nadpisuje, co robi Equals()/==.

Trzy sposoby porównywania - i które którego typu dotyczą

1. ReferenceEquals() - zawsze porównanie tożsamości, niezależnie od typu

object.ReferenceEquals(c1, c2); // false - różne obiekty w pamięci (dotyczy I class, I record)
object.ReferenceEquals(r1, r1); // true - to TEN SAM obiekt

To jest jedyny sposób, który zawsze działa identycznie, niezależnie od tego, czy masz class czy record - bo sprawdza fizyczną tożsamość w pamięci, ignorując jakąkolwiek nadpisaną logikę Equals.

2. Equals() - zależy od tego, co dana klasa/record definiuje

c1.Equals(c2); // false dla zwykłej class (dziedziczy Equals z object = reference equality)
r1.Equals(r2); // true dla record (kompilator wygenerował Equals oparte na wartościach)

3. Operator == - dla class domyślnie to samo co ReferenceEquals, dla record to samo co Equals

c1 == c2; // false - dla zwykłej class, == to alias na ReferenceEquals (chyba że przeciążysz operator)
r1 == r2; // true - record AUTOMATYCZNIE przeciąża == żeby wywoływał Equals (wartościowe porównanie)

Jak sprawić, żeby class porównywała się jak record - nadpisanie Equals/GetHashCode

Jeśli chcesz równości wartościowej dla zwykłej klasy (bez przechodzenia na record, np. bo potrzebujesz mutowalności ORAZ porównania po wartości), musisz to napisać ręcznie:

public class OrderClass : IEquatable<OrderClass>
{
    public int Id { get; set; }
    public string CustomerName { get; set; }

    // Nadpisanie Equals(object) - wymagane, dziedziczone z object
    public override bool Equals(object obj) => Equals(obj as OrderClass);

    // IEquatable<T>.Equals - bardziej wydajne (bez boxing/rzutowania), dobra praktyka
    public bool Equals(OrderClass other)
    {
        if (other is null) return false;
        if (ReferenceEquals(this, other)) return true; // optymalizacja - ten sam obiekt
        return Id == other.Id && CustomerName == other.CustomerName;
    }

    // GetHashCode MUSI być spójny z Equals - jeśli Equals zwraca true, hash MUSI być identyczny
    public override int GetHashCode() => HashCode.Combine(Id, CustomerName);

    // Przeciążenie operatorów == i != - żeby zachowywały się jak Equals
    public static bool operator ==(OrderClass left, OrderClass right)
        => left is null ? right is null : left.Equals(right);

    public static bool operator !=(OrderClass left, OrderClass right) => !(left == right);
}
var c1 = new OrderClass { Id = 1, CustomerName = "Jan" };
var c2 = new OrderClass { Id = 1, CustomerName = "Jan" };
c1 == c2;       // TERAZ true - bo przeciążyliśmy operator
c1.Equals(c2);  // true

To jest dokładnie kod, który record generuje za Ciebie automatycznie - widzisz teraz "cenę" tej wygody: dla class musisz to napisać ręcznie (i pamiętać o GetHashCode, IEquatable<T>, przeciążeniu operatorów), dla record dostajesz to za darmo z jednej linijki.

Kluczowa zasada: Equals i GetHashCode MUSZĄ być spójne

To jest klasyczne pytanie-pułapka na rozmowie - jeśli nadpiszesz Equals(), musisz też nadpisać GetHashCode(), inaczej łamiesz kontrakt:

// ❌ BŁĄD - Equals nadpisany, GetHashCode NIE
public class Order
{
    public int Id { get; set; }
    public override bool Equals(object obj) => obj is Order o && o.Id == Id;
    // BRAK GetHashCode() - kompilator da WARNING (CS0659), ale się skompiluje
}

Konsekwencja praktyczna - to psuje HashSet/Dictionary:

var order1 = new Order { Id = 1 };
var order2 = new Order { Id = 1 };

order1.Equals(order2); // true - "logicznie" to ten sam order

var set = new HashSet<Order>();
set.Add(order1);
set.Contains(order2); // MOŻE zwrócić false! - bo GetHashCode() dziedziczony z object
                        // daje RÓŻNE hashe dla order1 i order2 (bo to różne obiekty w pamięci),
                        // więc HashSet szuka w ZŁYM "kubełku" i nigdy nie znajduje dopasowania

record zawsze generuje spójną parę Equals/GetHashCode, więc ten konkretny błąd jest w rekordach niemożliwy - to jedna z realnych, praktycznych zalet, nie tylko składniowa wygoda.

Porównanie kolekcji - record vs class w LINQ

var records1 = new List<OrderRecord> { new(1, "Jan"), new(2, "Anna") };
var records2 = new List<OrderRecord> { new(1, "Jan"), new(2, "Anna") };

records1.SequenceEqual(records2); // true - porównuje element po elemencie przez Equals (wartościowo)
var classes1 = new List<OrderClass> { new() { Id = 1 }, new() { Id = 2 } };
var classes2 = new List<OrderClass> { new() { Id = 1 }, new() { Id = 2 } };

classes1.SequenceEqual(classes2); // false - bo Equals dla class to reference equality, obiekty są różne

Porównywanie record z dziedziczeniem - uwzględnia dokładny typ

public record Animal(string Name);
public record Dog(string Name, string Breed) : Animal(Name);

Animal a = new Dog("Rex", "Labrador");
Animal b = new Animal("Rex"); // TYLKO Animal, nie Dog

a.Equals(b); // false - mimo że Name="Rex" pasuje, RUNTIME TYPE się różni (Dog vs Animal)

To jest różnica względem "naiwnego" ręcznego Equals w class, gdzie musisz sam pamiętać o sprawdzeniu typu (obj is Order o), a przy dziedziczeniu łatwo o błąd - record robi to poprawnie automatycznie przez wygenerowaną właściwość EqualityContract.

IEqualityComparer<T> - porównanie niestandardowe, niezależne od Equals/GetHashCode klasy

Czasem chcesz porównać obiekty inaczej niż domyślne zachowanie klasy - wtedy zamiast nadpisywać Equals na samej klasie, tworzysz osobny comparer:

public class OrderByIdComparer : IEqualityComparer<OrderClass>
{
    public bool Equals(OrderClass x, OrderClass y) => x?.Id == y?.Id; // porównanie TYLKO po Id
    public int GetHashCode(OrderClass obj) => obj.Id.GetHashCode();
}

var set = new HashSet<OrderClass>(new OrderByIdComparer());

To działa identycznie dla record i class - IEqualityComparer<T> to zewnętrzny mechanizm, niezależny od tego, jak sam typ definiuje swoją "domyślną" równość.

Tabela podsumowująca

Metoda porównania class (domyślnie) record (domyślnie) Po ręcznym nadpisaniu w class
ReferenceEquals() Tożsamość w pamięci Tożsamość w pamięci Tożsamość w pamięci (bez zmian)
Equals() Tożsamość (= ReferenceEquals) Wartość wszystkich pól Wartość (jeśli tak zaimplementujesz)
== Tożsamość (alias na ReferenceEquals) Wartość (przez wygenerowany Equals) Wartość (jeśli przeciążysz operator)
GetHashCode() Bazuje na tożsamości (domyślny z object) Bazuje na wartościach pól Musisz dopasować ręcznie do Equals

Praktyczna rada na rozmowę

"Domyślnie class porównuje przez referencję, record przez wartość wszystkich właściwości - to wynika z tego, że kompilator generuje dla recordów Equals/GetHashCode/operatory ==/!= automatycznie. Jeśli potrzebuję równości wartościowej dla class (np. bo muszę zachować mutowalność, której record z init nie daje), implementuję IEquatable<T> ręcznie, pamiętając o kluczowej zasadzie: Equals i GetHashCode muszą być spójne, inaczej psuje się zachowanie w HashSet/Dictionary. ReferenceEquals zawsze pozostaje niezmienny - sprawdza fizyczną tożsamość w pamięci, niezależnie od typu."

Postaw mi kawę