Różnica między klasą a rekordem w C
Fundamentalna różnica - semantyka równości
public class OrderClass
{
public int Id { get; set; }
public string CustomerName { get; set; }
}
public record OrderRecord(int Id, string CustomerName);
var a = new OrderClass { Id = 1, CustomerName = "Jan" };
var b = new OrderClass { Id = 1, CustomerName = "Jan" };
Console.WriteLine(a == b); // false - RÓŻNE obiekty w pamięci (porównanie referencji)
Console.WriteLine(a.Equals(b)); // false - to samo
var c = new OrderRecord(1, "Jan");
var d = new OrderRecord(1, "Jan");
Console.WriteLine(c == d); // true - TE SAME wartości (porównanie wartościowe)
Console.WriteLine(c.Equals(d)); // true - to samo
Class - domyślnie reference equality (czy to ten sam obiekt w pamięci). Record - domyślnie value equality (czy wszystkie właściwości mają te same wartości).
Skąd to się bierze - co generuje kompilator
Dla record kompilator automatycznie generuje: konstruktor, właściwości init, przeciążony Equals()/GetHashCode() oparty na porównaniu wszystkich pól, ToString(), operatory ==/!=, metodę Deconstruct(). Dla class musisz to wszystko pisać ręcznie, jeśli chcesz podobnego zachowania.
Mutowalność - kolejna kluczowa różnica
public class OrderClass
{
public int Id { get; set; } // set - można zmieniać w dowolnym momencie
}
public record OrderRecord(int Id); // init - tylko przy tworzeniu
var orderClass = new OrderClass { Id = 1 };
orderClass.Id = 2; // ✅ OK - class jest mutowalny domyślnie
var orderRecord = new OrderRecord(1);
orderRecord.Id = 2; // ❌ Błąd kompilacji - init-only, nie da się zmienić po utworzeniu
Zmiana z niemutowalnym recordem - with:
var updated = orderRecord with { Id = 2 }; // NOWA instancja, oryginał niezmieniony
ToString() - czytelna reprezentacja "za darmo"
var orderClass = new OrderClass { Id = 1, CustomerName = "Jan" };
Console.WriteLine(orderClass);
// OrderClass - domyślny ToString() z object, bezużyteczny (chyba że nadpiszesz ręcznie)
var orderRecord = new OrderRecord(1, "Jan");
Console.WriteLine(orderRecord);
// OrderRecord { Id = 1, CustomerName = Jan } - AUTOMATYCZNIE czytelny format
Dekonstrukcja - wbudowana w record
public record OrderRecord(int Id, string CustomerName);
var order = new OrderRecord(1, "Jan");
var (id, customerName) = order; // działa od razu, bez pisania własnego Deconstruct()
Dla class trzeba by ręcznie zaimplementować Deconstruct().
Składnia - positional vs "klasyczna" record
// Positional (skrócona) - najczęściej używana
public record OrderDto(int Id, string CustomerName, decimal TotalAmount);
// "Klasyczna" składnia record - jak class, ale z równością wartościową
public record OrderDto
{
public int Id { get; init; }
public string CustomerName { get; init; }
public decimal TotalAmount { get; init; }
}
Druga forma bywa potrzebna, gdy chcesz mieć dodatkową logikę walidacyjną w konstruktorze albo właściwości obliczane.
Dziedziczenie - obie wspierają, ale record ma dodatkowe zasady równości
public record Animal(string Name);
public record Dog(string Name, string Breed) : Animal(Name);
var dog1 = new Dog("Rex", "Labrador");
var dog2 = new Dog("Rex", "Labrador");
dog1 == dog2; // true - ale UWAGA:
Animal animal = dog1;
Animal sameAnimal = new Dog("Rex", "Labrador");
animal == sameAnimal; // true - record porównuje też RUNTIME TYPE, nie tylko właściwości bazowe!
To jest subtelna różnica względem class - record sprawdza, czy porównywane obiekty są dokładnie tego samego typu w runtime, więc Dog nigdy nie będzie "równy" hipotetycznemu innemu typowi dziedziczącemu po Animal, nawet z tymi samymi wartościami pól.
record class vs record struct
public record OrderDto(int Id); // domyślnie: record CLASS (typ referencyjny, na stercie)
public record struct PointDto(int X, int Y); // record STRUCT (typ wartościowy, na stosie)
record struct łączy semantykę wartości record z semantyką pamięciową struct - kopiowanie przez wartość, brak alokacji na stercie. Przydatne dla małych, prostych danych.
Tabela porównawcza
class |
record |
|
|---|---|---|
| Równość domyślna | Referencyjna (ten sam obiekt) | Wartościowa (te same dane) |
| Mutowalność | Domyślnie mutowalny (set) |
Domyślnie niemutowalny (init) |
ToString() |
Domyślny, bezużyteczny | Automatyczny, czytelny |
| Dekonstrukcja | Trzeba pisać ręcznie | Wbudowana (dla positional) |
with (kopiowanie ze zmianą) |
Nie wspiera | Wspiera natywnie |
| Typ pamięciowy | Referencyjny (sterta) | Referencyjny (sterta), chyba że record struct |
| Kiedy używać | Encje z tożsamością, obiekty z zachowaniem i mutowalnym stanem | Dane (DTO, Command/Query), wartości, gdzie liczy się "co", nie "który" |
Kiedy który wybrać - praktyczna reguła
record:
- DTO w Web API (OrderDto)
- Command/Query w CQRS (GetOrderQuery(int OrderId))
- Wszędzie, gdzie dwa obiekty o tych samych danych powinny być uznane za "te same"
- Gdy chcesz niemutowalności domyślnie
class:
- Encje EF Core (Order z bazy) - wymagają mutacji dla change trackingu (order.Status = "Shipped"), a record z init-only property by to uniemożliwił
- Serwisy, ViewModel, repozytoria - obiekty z zachowaniem, nie tylko danymi
- Gdy tożsamość obiektu ma znaczenie niezależnie od wartości pól (dwa Order o tym samym Id, ale różnym Status w czasie, to wciąż "ten sam" order koncepcyjnie - to nie pasuje do "equality po wszystkich wartościach")
Pytanie-pułapka na rozmowie
"Czy encja EF Core powinna być recordem?" - Zwykle nie. EF Core opiera się na change trackingu przez mutację właściwości (o czym mówiliśmy przy Change Tracking) - potrzebuje set, nie init. Poza tym semantyka "równości po tożsamości" (ten sam wiersz w bazie, identyfikowany przez klucz główny) lepiej pasuje do class niż "równości po wszystkich wartościach" z record - dwa Order o tym samym Id, ale z jedną zmienioną właściwością, to koncepcyjnie wciąż "ten sam" zamówienie, a record uznałby je za różne obiekty (bo różnią się wartością).