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
classporównuje przez referencję,recordprzez wartość wszystkich właściwości - to wynika z tego, że kompilator generuje dla recordówEquals/GetHashCode/operatory==/!=automatycznie. Jeśli potrzebuję równości wartościowej dlaclass(np. bo muszę zachować mutowalność, którejrecordzinitnie daje), implementujęIEquatable<T>ręcznie, pamiętając o kluczowej zasadzie:EqualsiGetHashCodemuszą być spójne, inaczej psuje się zachowanie wHashSet/Dictionary.ReferenceEqualszawsze pozostaje niezmienny - sprawdza fizyczną tożsamość w pamięci, niezależnie od typu."