C# Academy · Lektion

Kombination mit Properties und Basistypen

Leiten Sie Parameter an Basistypen und Properties weiter.

Lektion 4 von 413 Schritte

Kombination mit Properties und Basistypen ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Primärkonstruktoren mit Vererbung kombinieren

Eine abgeleitete Klasse mit einem Primärkonstruktor kann ihre Parameter mithilfe der Syntax : Base(args) im Kopf der Deklaration an eine Basisklasse weiterleiten.

using System;

class Animal(string name) {
    public string Name => name;
}

class Dog(string name) : Animal(name) {
    public string Speak() => Name + " says Woof";
}

Console.WriteLine(new Dog("Rex").Speak()); // Rex says Woof

Eine Teilmenge der Parameter weiterleiten

Die abgeleitete Klasse kann mehr Parameter annehmen als die Basisklasse und nur die relevanten Parameter weiterleiten.

using System;

class Shape(string color) {
    public string Color => color;
}

class Box(string color, int size) : Shape(color) {
    public int Size => size;
}

var b = new Box("red", 5);
Console.WriteLine(b.Color + " " + b.Size); // red 5

Argumente für die Basisklasse umwandeln

Sie können Argumente für den Konstruktor der Basisklasse inline im Kopf der Deklaration aus den Parametern der abgeleiteten Klasse berechnen.

using System;

class Label(string text) {
    public string Text => text;
}

class UpperLabel(string text) : Label(text.ToUpper()) {
}

Console.WriteLine(new UpperLabel("hi").Text); // HI

Eigenschaften zusätzlich hinzufügen

Ein Primärkonstruktor und explizite Eigenschaften können gemeinsam verwendet werden. Initialisieren Sie die Eigenschaften bei der Deklaration anhand der Parameter.

using System;

class Product(string name, decimal price) {
    public string Name { get; } = name;
    public decimal Price { get; set; } = price;
}

var p = new Product("Book", 12m);
p.Price = 10m;
Console.WriteLine(p.Name + " " + p.Price); // Book 10

Basisparameter und Verwendung in der abgeleiteten Klasse

Auch nach der Weiterleitung an die Basisklasse kann ein Parameter des Primärkonstruktors in der abgeleiteten Klasse weiterhin im Klassenkörper verwendet werden.

using System;

class Base(int id) {
    public int Id => id;
}

class Item(int id, string label) : Base(id) {
    public string Describe() => "#" + id + ": " + label;
}

Console.WriteLine(new Item(7, "Widget").Describe()); // #7: Widget

Records und Primärkonstruktoren

Records verwenden Primärkonstruktoren, um automatisch öffentliche Eigenschaften zu erzeugen, die nur mit init gesetzt werden können. Ein Positions-Record ist der kompakteste Fall.

using System;

record Person(string First, string Last) {
    public string Full => First + " " + Last;
}

Console.WriteLine(new Person("Ada", "Lovelace").Full); // Ada Lovelace

Record-Vererbung

Abgeleitete Records leiten ihre Werte positionsbasiert an einen Basis-Record weiter und erzeugen die zusammengefasste Menge an Eigenschaften.

using System;

record Vehicle(string Make);
record Car(string Make, int Doors) : Vehicle(Make);

var c = new Car("Toyota", 4);
Console.WriteLine(c.Make + " " + c.Doors); // Toyota 4

Validierung vor dem Aufruf der Basisklasse

Wenn Sie eine Validierung benötigen, führen Sie sie in einem Eigenschaftsinitialisierer mithilfe eines throw-Ausdrucks durch. Der Aufruf der Basisklasse wird trotzdem zuerst ausgeführt.

using System;

class Base(string tag) { public string Tag => tag; }

class Node(string tag) : Base(tag) {
    public string Tag2 { get; } =
        tag.Length > 0 ? tag : throw new ArgumentException("empty");
}

Console.WriteLine(new Node("a").Tag); // a

Erfasste Parameter und Eigenschaften kombinieren

Sie können einige Parameter als erfassten privaten Zustand beibehalten und andere als Eigenschaften bereitstellen, um die öffentliche Schnittstelle gezielt zu gestalten.

using System;

class Order(int id, decimal total) {
    public decimal Total { get; } = total; // public
    public string Reference() => "ORD-" + id;   // id stays private
}

var o = new Order(42, 99m);
Console.WriteLine(o.Reference() + " " + o.Total); // ORD-42 99

Standardwerte für Eigenschaften

Eigenschaften, die nicht an Parameter gebunden sind, können weiterhin über Standardinitialisierer mit Werten versehen werden und lassen sich frei mit Parametern eines Primärkonstruktors kombinieren.

using System;

class Session(string user) {
    public string User { get; } = user;
    public bool Active { get; set; } = true;
}

var s = new Session("kai");
Console.WriteLine(s.User + " " + s.Active); // kai True

Alles zusammenführen

Eine abgeleitete Klasse, die Parameter an eine Basisklasse weiterleitet, eine Eigenschaft hinzufügt und ein berechnetes Member bereitstellt.

using System;

class Employee(string name) {
    public string Name => name;
}

class Manager(string name, int teamSize) : Employee(name) {
    public int TeamSize { get; } = teamSize;
    public string Title => Name + " (manages " + TeamSize + ")";
}

Console.WriteLine(new Manager("Sam", 5).Title); // Sam (manages 5)

Kurze Überprüfung

Überprüfen Sie, wie Primärkonstruktoren Parameter an Basisklassen weiterleiten.

Beantworte es in der interaktiven Lektion

Zusammenfassung

Sie haben gelernt, Primärkonstruktoren mit Eigenschaften und Basisklassen zu kombinieren.

class D(...) : Base(args) leitet Parameter an die Basisklasse weiter.
Argumente für die Basisklasse können inline berechnet werden.
Eigenschaften können bei der Deklaration anhand von Parametern initialisiert werden.
Records erzeugen aus Positionsparametern öffentliche Eigenschaften, die nur mit init gesetzt werden können.

Kostenlos starten

Lerne C# mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 93
Lektionen: 346

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Kombination mit Properties und Basistypen“ kostenlos?

Ja — der vollständige Text von „Kombination mit Properties und Basistypen“ 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 „Kombination mit Properties und Basistypen“?

Leiten Sie Parameter an Basistypen und Properties weiter. 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 4 von 4.

Wie lange dauert die Lektion „Kombination mit Properties und Basistypen“?

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

Primärkonstruktoren für Klassen
Parameter in Membern erfassen
Primärkonstruktoren für Structs
Kombination mit Properties und Basistypen

← Zurück zu C# Academy