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

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ą).

Postaw mi kawę