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

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 record w wersji positional (record OrderDto(int Id, string Name);) to jedna linijka zastępująca to, co w class wymagałoby osobnej deklaracji właściwości, konstruktora, i ręcznego nadpisania Equals, GetHashCode, ToString oraz 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 kluczowe record zamiast class włącza automatyczne generowanie tej całej logiki równości i ToString - to jest różnica semantyczna ukryta pod bardzo podobną składnią."

Postaw mi kawę