C# Academy · Lektion

Record-Typen: Grundlagen und Syntax

Deklarieren Sie Record-Klassen und Record-Structs, verstehen Sie die positionale Syntax und vergleichen Sie Records mit Klassen.

Record-Typen: Grundlagen und Syntax ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind Record-Typen

Records (in C# 9 eingeführt) sind Referenztypen, die für unveränderliche Daten mit Wertsemantik entwickelt wurden. Sie generieren automatisch Gleichheit auf Grundlage der Eigenschaftswerte und eine lesbare ToString()-Darstellung und unterstützen nicht-destruktive Änderungen über with-Ausdrücke.

Syntax für positionale Records

Die positionale Syntax ist die kompakteste Form. Eigenschaften, Konstruktor, Dekonstruktion und Gleichheit werden aus einer einzigen Zeile generiert.

// All in one line:
public record Point(double X, double Y);
public record Person(string FirstName, string LastName, int Age);

// Generated automatically:
// - Primary constructor: new Point(1.0, 2.0)
// - Deconstruct: var (x, y) = point;
// - Equality: p1 == p2 compares X and Y values
// - ToString: "Point { X = 1, Y = 2 }"

Records und Klassen

Records und Klassen unterscheiden sich hauptsächlich in ihrer standardmäßigen Gleichheit und ihrer Zielsetzung. Records verwenden strukturelle Gleichheit (Werte), Klassen verwenden Referenzgleichheit (Identität).

var p1 = new Point(1, 2);
var p2 = new Point(1, 2);
var p3 = p1;

// Record: structural equality
Console.WriteLine(p1 == p2); // True — same values
Console.WriteLine(p1 == p3); // True — same values

// Compare with a class:
var c1 = new PointClass(1, 2);
var c2 = new PointClass(1, 2);
Console.WriteLine(c1 == c2); // False — different references

Record-Structs

C# 10 ergänzt record struct – Records als Werttypen. Sie bieten dieselben Funktionen für Gleichheit und ToString wie Record-Klassen, werden aber wie structs auf dem Stack angelegt.

// Record struct: value type, stack-allocated
public record struct Color(byte R, byte G, byte B);

var red   = new Color(255, 0, 0);
var red2  = new Color(255, 0, 0);
Console.WriteLine(red == red2); // True — value equality

// Readonly record struct: fully immutable
public readonly record struct Coord(double Lat, double Lng);

Standardmäßige Record-Deklaration mit Rumpf

Records können einen vollständigen Rumpf enthalten – mit berechneten Eigenschaften, Methoden und Validierung im Konstruktor, wobei die automatische Gleichheit und ToString-Funktion erhalten bleiben.

public record Person(string FirstName, string LastName)
{
    // Computed property
    public string FullName => $"{FirstName} {LastName}";

    // Validation in constructor
    public Person : this(FirstName, LastName)
    {
        if (string.IsNullOrWhiteSpace(FirstName))
            throw new ArgumentException("FirstName required");
    }

    // Method
    public Person WithUpperCase() =>
        this with { FirstName = FirstName.ToUpper(), LastName = LastName.ToUpper() };
}

Vererbung mit Records

Records unterstützen Vererbung. Ein abgeleiteter Record fügt weitere Eigenschaften hinzu und folgt denselben Gleichheitsregeln – zwei Records sind nur dann gleich, wenn ihre Typen und alle Werte übereinstimmen.

public record Shape(string Color);
public record Circle(string Color, double Radius) : Shape(Color);
public record Rectangle(string Color, double Width, double Height) : Shape(Color);

var c1 = new Circle("red", 5.0);
var c2 = new Circle("red", 5.0);
var r1 = new Rectangle("red", 5.0, 3.0);

Console.WriteLine(c1 == c2); // True
Console.WriteLine(c1 == r1); // False — different types

Nicht-positionale Record-Eigenschaften

Records sind nicht auf positionale Parameter beschränkt. Sie können positionale und manuell deklarierte Eigenschaften kombinieren und Eigenschaftsinitialisierer für Standardwerte verwenden.

public record Order
{
    public int Id { get; init; }
    public string CustomerName { get; init; } = "";
    public List<OrderLine> Lines { get; init; } = new();
    public DateTime CreatedAt { get; init; } = DateTime.UtcNow;
    public OrderStatus Status { get; init; } = OrderStatus.Pending;
}

// Initialization:
var order = new Order
{
    Id = 42,
    CustomerName = "Alice"
    // Other props use defaults
};

Dekonstruktion

Positionale Records generieren automatisch eine Deconstruct-Methode, sodass sie in Zuweisungen und beim Pattern Matching destrukturiert werden können.

public record Point(double X, double Y);

var p = new Point(3.0, 4.0);

// Deconstruction
var (x, y) = p;
Console.WriteLine($"x={x}, y={y}");

// In switch:
string Describe(Point pt) => pt switch
{
    (0, 0) => "Origin",
    (double x, 0) => $"On X-axis at {x}",
    (0, double y) => $"On Y-axis at {y}",
    var (px, py)  => $"Point ({px}, {py})"
};

Records als DTOs

Records eignen sich hervorragend für DTOs von API-Anfragen und -Antworten. Sie sind unveränderlich und serialisierbar, und ihre automatisch generierte Gleichheit vereinfacht Tests.

// API request/response records
public record CreateProductRequest(
    string Name,
    decimal Price,
    int Stock);

public record ProductResponse(
    int Id,
    string Name,
    decimal Price,
    int Stock,
    DateTime CreatedAt);

// In controller:
app.MapPost("/products", (CreateProductRequest req, ProductService svc) =>
{
    var product = svc.Create(req.Name, req.Price, req.Stock);
    return Results.Created($"/products/{product.Id}",
        new ProductResponse(product.Id, product.Name,
                            product.Price, product.Stock,
                            product.CreatedAt));
});

Record-Gleichheit in Unit-Tests

Wertgleichheit macht Records ideal für Assertions in Unit-Tests. Sie können erwartete und tatsächliche Records mit == oder Assert.Equal ohne eigene Comparer vergleichen.

[Fact]
public async Task CreateOrder_ReturnsCorrectResponse()
{
    var response = await _client.PostAsJsonAsync("/orders",
        new CreateOrderRequest(CustomerId: 1, ProductId: 5, Quantity: 2));

    var order = await response.Content.ReadFromJsonAsync<OrderResponse>();

    // Simple equality check — no custom IEqualityComparer needed!
    Assert.Equal(
        new OrderResponse(Id: order!.Id, Status: "Pending", Total: 99.98m),
        order);
}

Schnelltest

Welche Gleichheitssemantik verwenden C#-Records standardmäßig?

Zusammenfassung: Grundlagen von Record-Typen

Wichtige Erkenntnisse:

Records sind standardmäßig Referenztypen mit Wertgleichheit (struktureller Gleichheit)
Die positionale Syntax generiert Konstruktor, Dekonstruktion, Gleichheit und ToString
record struct (C# 10) ist eine Variante als Werttyp
Records unterstützen Vererbung – für die Gleichheit muss auch der Typ übereinstimmen
Sie eignen sich ideal für DTOs, API-Verträge und Assertions in Unit-Tests
Fügen Sie in einem Rumpfblock neben den positionalen Parametern berechnete Eigenschaften und Methoden hinzu

Häufig gestellte Fragen

Ist die Lektion „Record-Typen: Grundlagen und Syntax“ kostenlos?

Ja — der vollständige Text von „Record-Typen: Grundlagen und Syntax“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Record-Typen: Grundlagen und Syntax“?

Deklarieren Sie Record-Klassen und Record-Structs, verstehen Sie die positionale Syntax und vergleichen Sie Records mit Klassen. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Record-Typen: Grundlagen und Syntax“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C# Academy