Co jsou záznamy (records) v C#?

Question

Accepted Answer

**Records** (C# 9+) jsou stručný způsob, jak definovat typy, které jsou primárně **neměnné nositele dat** s **rovností založenou na hodnotě**. Automaticky generují boilerplate (konstruktor, rovnost, `ToString` atd.), což je ideální pro DTO, doménové hodnoty a modelování dat.

## Definování záznamu (poziční syntax)

```csharp
// one line generates: constructor, properties, equality, ToString, deconstruction
public record Person(string Name, int Age);

var p1 = new Person("Ann", 30);
p1.Name;                          // "Ann" (read-only property)
Console.WriteLine(p1);             // Person { Name = Ann, Age = 30 } — ToString generated
```

Pozicí syntax `record Person(string Name, int Age)` generuje vše — vlastnosti, konstruktor, `ToString`, rovnost, dekonstrukci — eliminuje boilerplate, který by vyžadovala běžná třída.

## Rovnost založená na hodnotě (klíčový rozdíl od tříd)

```csharp
var a = new Person("Ann", 30);
var b = new Person("Ann", 30);
a == b;        // TRUE — records compare by VALUE (all properties equal)
// (a regular class would be FALSE here — classes compare by reference)
```

Na rozdíl od tříd (které porovnávají podle identity referencí) záznamy porovnávají podle **hodnoty** — dva záznamy se stejnými hodnotami vlastností jsou si rovny. To je přesně to, co chcete pro datové objekty.

## Neměnnost a nedestruktivní mutace (with)

```csharp
public record Person(string Name, int Age);   // properties are init-only (immutable)

var p1 = new Person("Ann", 30);
var p2 = p1 with { Age = 31 };   // `with` creates a COPY with some properties changed
// p1 unchanged (immutable); p2 = Person { Name = Ann, Age = 31 }
```

Záznamy jsou standardně neměnné a výraz **`with`** vytvoří upravenou kopii (nedestruktivní mutace) — ideální pro práci s neměnnými daty.

## record class vs record struct

```csharp
public record class Ref(int X);    // a reference type (default) with value equality
public record struct Val(int X);   // a VALUE type record (C# 10)
```

## Proč je to důležité

Záznamy jsou důležitá moderní funkce C# (C# 9+), která činí definování neměnných datových typů stručným a správným, takže jejich pochopení je cenné pro moderní vývoj v C#.

Jejích klíčové výhody řeší skutečné potřeby: **eliminují boilerplate** (automaticky generují konstruktory, vlastnosti, `ToString`, rovnost a dekonstrukci z jednoho řádku deklarace — versus podstatný kód, který vyžaduje běžná třída), a poskytují **rovnost založenou na hodnotě** (dva záznamy s rovnými vlastnostmi jsou si rovny, na rozdíl od tříd, které porovnávají podle reference) — což je přesně chování, které chcete pro datové objekty, DTO a doménové hodnoty, a které třídy standardně udělají špatně.

Záznamy jsou také **standardně neměnné** s elegantním výrazem **`with`** pro nedestruktivní mutaci (vytváření upravených kopií), což podporuje neměnný, funkční styl, který je stále více upřednostňován pro bezpečnější a předvídatelnější kód.

Pochopení záznamů — stručné syntaxe, rovnosti hodnot, neměnnosti s `with` a record structs — je cenné pro psaní čistého moderního C#, protože jsou idiomatickým způsobem modelování dat (DTO, API modely, objekty hodnot, neměnný stav) a jsou často používány v současných kódech.

Vědět, kdy použít záznam (neměnná data se sémantikou hodnot) versus třídu (měnné objekty s identitou a bohatým chováním) odráží plynulost s moderním C#.

Protože záznamy dramaticky zjednodušují modelování dat a zároveň poskytují správnou rovnost a neměnnost — běžné potřeby, které byly před tím únavné a náchylné k chybám — jsou důležitou a často používanou funkcí, která je charakteristikou moderního, čistého kódu v C#.