Was sind Records in C#?

Question

Accepted Answer

**Records** (C# 9+) sind eine prägnante Möglichkeit, Typen zu definieren, die primär **unveränderliche Datencontainer** mit **wertbasierter Gleichheit** sind. Sie generieren automatisch Boilerplate-Code (Konstruktor, Gleichheit, `ToString` usw.) und sind daher ideal für DTOs, Domain Values und Datenmodellierung.

## Records definieren (Positional-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
```

Die Positional-Syntax `record Person(string Name, int Age)` generiert alles — Eigenschaften, Konstruktor, `ToString`, Gleichheit, Dekonstruktion — und beseitigt den Boilerplate-Code, den eine reguläre Klasse benötigen würde.

## Wertbasierte Gleichheit (der Schlüsselunterschied zu Klassen)

```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)
```

Im Gegensatz zu Klassen (die nach Referenzidentität vergleichen) vergleichen Records nach **Wert** — zwei Records mit denselben Eigenschaftswerten sind gleich. Das ist genau das, was man für Datenobjekte möchte.

## Unveränderlichkeit und nicht-destruktive Mutation (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 }
```

Records sind standardmäßig unveränderlich, und der **`with`-Ausdruck** erstellt eine modifizierte Kopie (nicht-destruktive Mutation) — ideal für die Arbeit mit unveränderlichen Daten.

## 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)
```

## Warum es wichtig ist

Records sind ein wichtiges modernes C#-Feature (C# 9+), das die Definition unveränderlicher Datentypen prägnant und korrekt macht, daher ist das Verständnis davon für moderne C#-Entwicklung wertvoll.

Ihre Schlüsselvorteile adressieren reale Anforderungen: Sie **beseitigen Boilerplate-Code** (generieren automatisch Konstruktoren, Eigenschaften, `ToString`, Gleichheit und Dekonstruktion aus einer einzeiligen Deklaration — im Gegensatz zum erheblichen Code, den eine reguläre Klasse erfordert), und sie bieten **wertbasierte Gleichheit** (zwei Records mit gleichen Eigenschaften sind gleich, im Gegensatz zu Klassen, die nach Referenz vergleichen) — das ist genau das Verhalten, das man für Datenobjekte, DTOs und Domain Values möchte, und das Klassen standardmäßig falsch machen.

Records sind auch **standardmäßig unveränderlich** mit dem eleganten **`with`-Ausdruck** für nicht-destruktive Mutation (das Erstellen von modifizierten Kopien), was den unveränderlichen, funktionalen Stil unterstützt, der zunehmend für sichereren, vorhersehbareren Code bevorzugt wird.

Das Verständnis von Records — die prägnante Syntax, Wertequalität, Unveränderlichkeit mit `with` und Record Structs — ist wertvoll für das Schreiben von sauberem modernem C#, da sie die idiomatische Methode zur Modellierung von Daten (DTOs, API-Modelle, Value Objects, unveränderlicher State) sind und in aktuellen Codebases weit verbreitet sind.

Zu wissen, wann man ein Record (unveränderliche Daten mit Wert-Semantik) statt einer Klasse (veränderliche Objekte mit Identität und umfassendem Verhalten) verwendet, spiegelt Vertrautheit mit modernem C# wider.

Da Records die Datenmodellierung dramatisch vereinfachen und gleichzeitig korrekte Gleichheit und Unveränderlichkeit bieten — häufige Anforderungen, die vorher mühsam und fehleranfällig waren — sind sie ein wichtiges, häufig verwendetes Feature, das ein Kennzeichen von modernem, sauberem C#-Code ist.