Porównanie deklaracji record i class w C# - składnia obok siebie
1. Najprostszy przypadek - dane bez logiki
// CLASS - pełna, rozwlekła składnia
public class OrderClass
{
public int Id { get; set; }
public string CustomerName { get; set; }
public decimal TotalAmount { get; set; }
}
// RECORD - positional syntax, jedna linijka
public record OrderRecord(int Id, string CustomerName, decimal TotalAmount);
Ta jedna linijka record generuje automatycznie to, co w class musisz napisać ręcznie (i więcej) - zobaczmy dokładnie co konkretnie kryje się pod tą skróconą składnią.
2. Co faktycznie generuje kompilator dla record - "rozwinięcie" positional record
Żeby zrozumieć różnicę, warto zobaczyć, do czego w przybliżeniu kompiluje się public record OrderRecord(int Id, string CustomerName, decimal TotalAmount);:
// To, co MUSISZ napisać ręcznie w class, żeby uzyskać RÓWNOWAŻNE zachowanie do record:
public class OrderRecordEquivalent : IEquatable<OrderRecordEquivalent>
{
// Właściwości - init, nie set (niemutowalność)
public int Id { get; init; }
public string CustomerName { get; init; }
public decimal TotalAmount { get; init; }
// Konstruktor pozycyjny
public OrderRecordEquivalent(int id, string customerName, decimal totalAmount)
{
Id = id;
CustomerName = customerName;
TotalAmount = totalAmount;
}
// Equals (wartościowy, nie referencyjny)
public override bool Equals(object obj) => Equals(obj as OrderRecordEquivalent);
public bool Equals(OrderRecordEquivalent other)
{
if (other is null) return false;
if (ReferenceEquals(this, other)) return true;
return Id == other.Id && CustomerName == other.CustomerName && TotalAmount == other.TotalAmount;
}
// GetHashCode spójny z Equals
public override int GetHashCode() => HashCode.Combine(Id, CustomerName, TotalAmount);
// Operatory == i !=
public static bool operator ==(OrderRecordEquivalent left, OrderRecordEquivalent right)
=> left is null ? right is null : left.Equals(right);
public static bool operator !=(OrderRecordEquivalent left, OrderRecordEquivalent right) => !(left == right);
// ToString - czytelna reprezentacja
public override string ToString()
=> $"OrderRecordEquivalent {{ Id = {Id}, CustomerName = {CustomerName}, TotalAmount = {TotalAmount} }}";
// Deconstruct - dekonstrukcja
public void Deconstruct(out int id, out string customerName, out decimal totalAmount)
{
id = Id;
customerName = CustomerName;
totalAmount = TotalAmount;
}
// "with" wymaga specjalnego konstruktora kopiującego - w prawdziwym record generowanego automatycznie
protected OrderRecordEquivalent(OrderRecordEquivalent original)
{
Id = original.Id;
CustomerName = original.CustomerName;
TotalAmount = original.TotalAmount;
}
}
To wszystko kryje się pod jedną linijką record. To jest chyba najbardziej przekonujący sposób pokazania różnicy na rozmowie - record to nie "inny słowny kluczowy dla tego samego", tylko realna redukcja boilerplate'u o kilkadziesiąt linijek.
3. Deklaracja właściwości - set vs init
// CLASS - domyślnie mutowalna (set)
public class OrderClass
{
public int Id { get; set; }
}
var c = new OrderClass { Id = 1 };
c.Id = 2; // ✅ OK w dowolnym momencie
// RECORD (positional) - domyślnie init-only
public record OrderRecord(int Id);
var r = new OrderRecord(1);
r.Id = 2; // ❌ Błąd kompilacji
// RECORD można też zrobić mutowalny, jeśli jawnie użyjesz "set"
public record MutableOrderRecord
{
public int Id { get; set; } // jawne "set" zamiast domyślnego init z positional syntax
}
To pokazuje, że record nie jest z definicji niemutowalny - to positional syntax generuje init domyślnie, ale możesz to nadpisać, pisząc właściwości ręcznie z set.
4. "Klasyczna" składnia record (bez positional) - bliżej wyglądem do class
// CLASS
public class OrderClass
{
public int Id { get; set; }
public string CustomerName { get; set; }
public OrderClass(int id, string customerName)
{
Id = id;
CustomerName = customerName;
}
}
// RECORD - "klasyczna" składnia, bardzo podobna do class, RÓŻNI SIĘ tylko słowem kluczowym
public record OrderRecord
{
public int Id { get; init; } // init zamiast set - ale możesz dać "set" jeśli chcesz mutowalności
public string CustomerName { get; init; }
public OrderRecord(int id, string customerName)
{
Id = id;
CustomerName = customerName;
}
}
Kluczowy wniosek: samo słowo record zamiast class już samo w sobie daje Ci wygenerowany Equals/GetHashCode/ToString/operatory ==/!= - niezależnie od tego, czy używasz skróconej (positional) czy pełnej składni. Positional to dodatkowy "bonus" (automatyczny konstruktor + właściwości), ale sama zamiana class → record już zmienia semantykę równości.
5. Dziedziczenie - składnia niemal identyczna, semantyka różna
// CLASS
public class Animal
{
public string Name { get; set; }
public Animal(string name) => Name = name;
}
public class Dog : Animal
{
public string Breed { get; set; }
public Dog(string name, string breed) : base(name) => Breed = breed;
}
// RECORD - positional, dużo krócej
public record Animal(string Name);
public record Dog(string Name, string Breed) : Animal(Name); // "base" wywołany w nagłówku dziedziczenia
6. record class vs record struct - dodatkowa oś, której class nie ma
public record OrderDto(int Id); // domyślnie: record CLASS (referencyjny, sterta)
public record class OrderDtoExplicit(int Id); // to samo, jawnie
public record struct PointDto(int X, int Y); // record STRUCT (wartościowy, stos)
class nie ma odpowiednika record struct - zwykły struct nie generuje automatycznie Equals/GetHashCode po wartościach tak dokładnie jak record struct (choć struct sam w sobie domyślnie porównuje pola przez refleksję w ValueType.Equals, co jest wolniejsze niż wygenerowany kod w record struct).
7. Modyfikator sealed przy dziedziczeniu record - subtelna różnica
public record Animal(string Name);
public record Dog(string Name, string Breed) : Animal(Name);
Kompilator automatycznie generuje w Dog metodę porównującą EqualityContract (chronioną właściwość, którą widzieliśmy pośrednio przy dziedziczeniu recordów) - to jest mechanizm unikalny dla record, którego class w ogóle nie ma, bo class nie generuje żadnej automatycznej logiki równości.
Zestawienie - tabela różnic w samej deklaracji
| Element składni | class |
record (positional) |
record (klasyczna składnia) |
|---|---|---|---|
| Deklaracja właściwości | Trzeba pisać jawnie | Generowane z parametrów | Trzeba pisać jawnie |
| Domyślny accessor | { get; set; } (jeśli tak napiszesz) |
{ get; init; } automatycznie |
Musisz sam wybrać set/init |
| Konstruktor | Trzeba pisać jawnie (lub domyślny bezparametrowy) | Generowany z parametrów positional | Trzeba pisać jawnie |
Equals/GetHashCode |
Dziedziczone z object (referencja) |
Generowane (wartość) | Generowane (wartość) |
ToString() |
Dziedziczony z object (bezużyteczny) |
Generowany (czytelny) | Generowany (czytelny) |
Deconstruct() |
Trzeba pisać ręcznie | Generowany automatycznie | Trzeba pisać ręcznie |
with expression |
Nie wspiera | Wspiera | Wspiera |
Operatory ==/!= |
Dziedziczone (referencja), można przeciążyć ręcznie | Generowane (wartość) | Generowane (wartość) |
Minimalna, zwięzła odpowiedź na to pytanie na rozmowie
"Składniowo
recordw wersji positional (record OrderDto(int Id, string Name);) to jedna linijka zastępująca to, co wclasswymagałoby osobnej deklaracji właściwości, konstruktora, i ręcznego nadpisaniaEquals,GetHashCode,ToStringoraz operatorów==/!=, jeśli chcemy równości wartościowej. Nawet 'klasyczna' składnia record (bez positional, z jawnymi property) wygląda niemal identycznie jak class, ale samo słowo kluczowerecordzamiastclasswłącza automatyczne generowanie tej całej logiki równości iToString- to jest różnica semantyczna ukryta pod bardzo podobną składnią."