0Pricing
C# Academy · Lektion

Primärkonstruktoren für Structs

Wenden Sie Primärkonstruktoren auf Werttypen an.

Primärkonstruktoren für Structs ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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 in Structs

Auch Structs unterstützen Primärkonstruktoren: struct Point(int x, int y). Sie funktionieren ähnlich wie bei Klassen und deklarieren Parameter im Kopf der Deklaration.

using System;

struct Point(int x, int y) {
    public int X => x;
    public int Y => y;
}

var p = new Point(3, 4);
Console.WriteLine(p.X + "," + p.Y); // 3,4

Ein parameterloser Konstruktor bleibt vorhanden

Structs verfügen immer über einen impliziten parameterlosen Konstruktor, der den Standardwert erzeugt. Ein Primärkonstruktor fügt daneben einen parametrisierten Konstruktor hinzu.

using System;

struct Vec(int x, int y) {
    public int X => x;
    public int Y => y;
}

var zero = new Vec(); // default: x=0, y=0
Console.WriteLine(zero.X + "," + zero.Y); // 0,0

Parameter über Eigenschaften bereitstellen

Wie bei Klassen sind die Parameter eines Primärkonstruktors eines Structs nicht automatisch öffentliche Eigenschaften. Stellen Sie sie ausdrücklich bereit.

using System;

struct Size(int w, int h) {
    public int Width { get; } = w;
    public int Height { get; } = h;
}

var s = new Size(10, 20);
Console.WriteLine(s.Width * s.Height); // 200

Berechnete Member

Primärkonstruktoren von Structs eignen sich besonders gut zusammen mit berechneten Membern mit Expression-Bodied-Syntax.

using System;

struct Complex(double re, double im) {
    public double Magnitude => Math.Sqrt(re * re + im * im);
}

Console.WriteLine(new Complex(3, 4).Magnitude); // 5

Readonly-Structs

Ein readonly struct mit einem Primärkonstruktor garantiert Unveränderlichkeit. Kein Member darf den Zustand verändern, was perfekt zu nur lesbaren Eigenschaften passt.

using System;

readonly struct Money(decimal amount, string currency) {
    public decimal Amount { get; } = amount;
    public string Currency { get; } = currency;
    public string Display => Amount.ToString("0.00") + " " + Currency;
}

Console.WriteLine(new Money(5m, "USD").Display); // 5.00 USD

Verkettung mit dem Primärkonstruktor

Zusätzliche Konstruktoren eines Structs müssen den Primärkonstruktor mit : this(...) aufrufen, genau wie bei Klassen.

using System;

struct Square(int side) {
    public int Side => side;
    public int Area => side * side;
    public Square() : this(1) { } // explicit default side
}

Console.WriteLine(new Square(4).Area); // 16

Standardkonstruktor und Primärkonstruktor

Beachten Sie, dass new Square() entweder die implizite Initialisierung mit Nullen oder Ihren deklarierten parameterlosen Konstruktor verwenden kann. Wenn Sie einen Konstruktor definieren, der verkettet ist, wird Ihre Logik ausgeführt.

using System;

struct Pct(double value) {
    public double Value { get; } = value;
    public Pct() : this(100) { }
}

Console.WriteLine(new Pct().Value); // 100

Wertsemantik bleibt erhalten

Structs werden weiterhin per Wert kopiert. Ein Primärkonstruktor ändert daran nichts: Beim Zuweisen eines Structs werden alle zugehörigen Felder kopiert.

using System;

struct Counter(int n) {
    public int N { get; set; } = n;
}

var a = new Counter(1);
var b = a;       // copy
b.N = 99;
Console.WriteLine(a.N + " " + b.N); // 1 99

Veränderliche Felder initialisieren

Sie können setzbare Eigenschaften oder Felder anhand von Parametern initialisieren, obwohl unveränderliche Structs in der Regel vorzuziehen sind.

using System;

struct Bag(int capacity) {
    public int Capacity { get; set; } = capacity;
    public int Used { get; set; } = 0;
}

var bag = new Bag(10);
bag.Used = 3;
Console.WriteLine(bag.Capacity - bag.Used); // 7

Dekonstruktion

Kombinieren Sie einen Primärkonstruktor mit einer Deconstruct-Methode, um ein tupelähnliches Entpacken zu ermöglichen.

using System;

struct Point(int x, int y) {
    public int X => x;
    public int Y => y;
    public void Deconstruct(out int a, out int b) { a = x; b = y; }
}

var (px, py) = new Point(7, 8);
Console.WriteLine(px + "," + py); // 7,8

Alles zusammenführen

Ein kleiner unveränderlicher Werttyp, der mit einem readonly struct und einem Primärkonstruktor erstellt wurde.

using System;

readonly struct Temperature(double celsius) {
    public double Celsius { get; } = celsius;
    public double Fahrenheit => Celsius * 9 / 5 + 32;
}

var t = new Temperature(25);
Console.WriteLine(t.Fahrenheit); // 77

Kurze Überprüfung

Testen Sie Ihr Verständnis von Primärkonstruktoren für Structs.

Zusammenfassung

Sie haben Primärkonstruktoren für Structs kennengelernt.

  • struct P(int x, int y) deklariert Parameter im Kopf der Deklaration.
  • Der implizite parameterlose Konstruktor bleibt vorhanden.
  • Kombinieren Sie sie mit readonly struct, um unveränderliche Werttypen zu erstellen.
  • Zusätzliche Konstruktoren werden mit : this(...) verkettet.

Häufig gestellte Fragen

Ist die Lektion „Primärkonstruktoren für Structs“ kostenlos?

Ja — der vollständige Text von „Primärkonstruktoren für Structs“ 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 „Primärkonstruktoren für Structs“?

Wenden Sie Primärkonstruktoren auf Werttypen an. 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 3 von 4.

Wie lange dauert die Lektion „Primärkonstruktoren für Structs“?

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

  1. Primärkonstruktoren für Klassen
  2. Parameter in Membern erfassen
  3. Primärkonstruktoren für Structs
  4. Kombination mit Properties und Basistypen
← Zurück zu C# Academy