Ein C# Struct ist ein Werttyp. Eine Variable vom Typ eines Structs enthält die Daten selbst und nicht, wie bei einer Klasse, einen Verweis auf ein Objekt. Wird ein Struct zugewiesen oder an eine Methode übergeben, entsteht deshalb eine Kopie. Änderungen an der Kopie wirken sich nicht auf das Original aus.
Structs eignen sich für kleine Datentypen, die einen einzelnen Wert darstellen, etwa einen Punkt mit X- und Y-Koordinate oder einen Geldbetrag mit Währung. Für die meisten anderen Typen ist eine Klasse die bessere Wahl.
Struct oder Klasse: der Unterschied
| struct | class | |
|---|---|---|
| Typart | Werttyp | Verweistyp |
| Zuweisung | kopiert die Daten | kopiert den Verweis |
| Vererbung | nicht möglich | möglich |
| Interfaces | können implementiert werden | können implementiert werden |
| Standardwert | alle Felder 0 bzw. null | null |
| Finalizer | nicht erlaubt | erlaubt |
Ein Struct definieren und verwenden
public struct Punkt
{
public double X;
public double Y;
public Punkt(double x, double y)
{
X = x;
Y = y;
}
public double AbstandZumNullpunkt()
{
return Math.Sqrt(X * X + Y * Y);
}
}
var p = new Punkt(3, 4);
Console.WriteLine(p.AbstandZumNullpunkt());
Ausgabe:
5
Ein Struct kann Felder, Eigenschaften, Konstruktoren und Methoden enthalten, genau wie eine Klasse. Wie Eigenschaften mit get, set und init funktionieren, erklärt der Beitrag zur C# Property.
Kopiersemantik: der wichtigste Unterschied in der Praxis
var a = new Punkt(1, 1);
var b = a; // Kopie
b.X = 10;
Console.WriteLine(a.X); // 1
Console.WriteLine(b.X); // 10
Bei einer Klasse würden a und b auf dasselbe Objekt zeigen, und a.X wäre ebenfalls 10. Beim Struct sind es zwei unabhängige Werte.
Dasselbe passiert bei Methodenaufrufen. Eine Methode, die einen Struct-Parameter verändert, verändert nur ihre eigene Kopie. Soll das Original geändert werden, übergibt man den Wert mit ref. Bei großen Structs in leistungskritischem Code kann man mit in oder ref readonly außerdem unnötige Kopien vermeiden.
readonly struct: unveränderliche Werte
Viele Fehler mit Structs entstehen, weil man versehentlich eine Kopie statt des Originals ändert. Ein readonly struct verhindert das von vornherein: Alle Felder müssen readonly sein, Eigenschaften dürfen nur get oder init haben.
public readonly struct Koordinate
{
public Koordinate(double x, double y)
{
X = x;
Y = y;
}
public double X { get; init; }
public double Y { get; init; }
}
Ändern lässt sich so ein Wert nur, indem man eine neue Instanz erzeugt. Mit dem with-Ausdruck geht das kurz:
var k1 = new Koordinate(0, 0);
var k2 = k1 with { X = 3 }; // k1 bleibt (0, 0), k2 ist (3, 0)
Auch wenn nicht das ganze Struct unveränderlich sein soll, kannst du einzelne Methoden und Eigenschaften als readonly kennzeichnen. Dann meldet der Compiler einen Fehler, wenn sie den Zustand verändern.
record struct: Werttyp mit eingebautem Vergleich
Ein record struct ist ein Struct, für das der Compiler zusätzlich Wertvergleich, ToString() und Dekonstruktion erzeugt. Die kürzeste Form ist eine Zeile:
public readonly record struct Geld(decimal Betrag, string Waehrung);
var preis = new Geld(20m, "EUR");
Console.WriteLine(preis);
Ausgabe:
Geld { Betrag = 20, Waehrung = EUR }
record struct gibt es seit C# 10. Mit readonly davor sind alle Eigenschaften unveränderlich, ohne readonly lassen sie sich setzen.
Konstruktoren und Standardwerte
Jedes Struct hat einen öffentlichen parameterlosen Konstruktor. Seit C# 10 darfst du ihn selbst schreiben und Feldern direkt einen Startwert geben. Dabei gibt es eine Falle: default und neue Arrays ignorieren deinen Konstruktor.
public struct Messwert
{
public Messwert()
{
Wert = double.NaN;
}
public double Wert { get; set; }
}
Console.WriteLine(new Messwert().Wert); // NaN
Console.WriteLine(default(Messwert).Wert); // 0
var feld = new Messwert[1];
Console.WriteLine(feld[0].Wert); // 0
default erzeugt immer das „leere“ Struct, in dem alle Felder 0, false oder null sind. Dein Code sollte mit diesem Zustand umgehen können.
Wann solltest du ein Struct verwenden?
Microsofts Entwurfsrichtlinien für .NET empfehlen ein Struct nur, wenn der Typ alle diese Eigenschaften hat:
- Er stellt logisch einen einzelnen Wert dar, ähnlich wie
intoderdouble. - Eine Instanz ist kleiner als 16 Byte.
- Er ist unveränderlich.
- Er muss nicht häufig geboxt werden, also nicht oft als
objectoder Interface behandelt.
In allen anderen Fällen raten die Richtlinien zu einer Klasse. Die 16-Byte-Grenze ist eine Faustregel aus der Zeit, als die Richtlinien entstanden. Sie zeigt aber die Richtung: Große Structs kosten bei jeder Kopie Zeit.
Typische Beispiele für Structs aus .NET selbst sind int, double, bool, DateTime, TimeSpan und Guid.
Häufige Fehler
Struct in einer Liste ändern
var punkte = new List<Punkt> { new Punkt(1, 1) };
// punkte[0].X = 5; // Compilerfehler: Rückgabewert ist eine Kopie
Der Indexer einer List<T> gibt eine Kopie zurück. Eine Änderung daran wäre wirkungslos, deshalb verbietet der Compiler sie. Lösung: Wert holen, ändern und zurückschreiben, oder gleich ein unveränderliches Struct verwenden.
Zu große Structs
Ein Struct mit vielen Feldern wird bei jeder Zuweisung und jedem Methodenaufruf komplett kopiert. Das kann langsamer sein als eine Klasse. Wächst ein Struct über einige wenige Felder hinaus, lohnt sich die Prüfung, ob eine Klasse passender ist.
Vererbung erwarten
Ein Struct kann nicht von einer anderen Klasse oder einem anderen Struct erben, und niemand kann von einem Struct erben. Gemeinsames Verhalten lässt sich aber über Interfaces abbilden.
Häufige Fragen zum C# Struct
Liegen Structs immer auf dem Stack?
Nein, das ist ein verbreiteter Irrtum. Ein Struct liegt dort, wo seine Variable liegt. Eine lokale Variable kann auf dem Stack liegen, ein Struct als Feld einer Klasse liegt dagegen zusammen mit dem Objekt auf dem Heap. Entscheidend für das Verhalten ist die Kopiersemantik, nicht der Speicherort.
Kann ein Struct null sein?
Ein normales Struct nicht, denn es ist ein Wert. Soll ein Struct „keinen Wert“ haben können, verwendest du einen nullable Typ, zum Beispiel Punkt? oder int?.
Wie fange ich mit C# an?
Einen Einstieg mit erstem Programm findest du im Beitrag C# lernen. Für Schleifen und Verzweigungen helfen die Artikel zur C# While-Schleife und zur C# Switch-Anweisung.