struct w C
Fundamentalna różnica - typ wartościowy vs referencyjny
To jest najważniejsza rzecz do zrozumienia - struct to typ wartościowy (value type), w przeciwieństwie do class, która jest typem referencyjnym (reference type).
public struct Point
{
public int X { get; set; }
public int Y { get; set; }
}
public class PointClass
{
public int X { get; set; }
public int Y { get; set; }
}
Gdzie żyją w pamięci - stos vs sterta
Point p1 = new Point { X = 1, Y = 2 }; // żyje na STOSIE (zazwyczaj, patrz niżej o wyjątkach)
PointClass c1 = new PointClass { X = 1, Y = 2 }; // c1 to referencja NA STOSIE, obiekt NA STERCIE
Struct - dane przechowywane bezpośrednio w miejscu, gdzie zmienna jest zadeklarowana (na stosie, jeśli to zmienna lokalna; wewnątrz obiektu, jeśli to pole klasy).
Class - zmienna to referencja (wskaźnik) do obiektu żyjącego na stercie; sama referencja jest mała (jak wskaźnik), ale prawdziwe dane są gdzie indziej.
Kluczowa konsekwencja - kopiowanie przez wartość
public struct Point { public int X { get; set; } public int Y { get; set; } }
Point p1 = new Point { X = 1, Y = 2 };
Point p2 = p1; // KOPIUJE całą strukturę - p2 to NIEZALEŻNA kopia
p2.X = 100;
Console.WriteLine(p1.X); // 1 - p1 się NIE zmieniło!
Console.WriteLine(p2.X); // 100
public class PointClass { public int X { get; set; } public int Y { get; set; } }
PointClass c1 = new PointClass { X = 1, Y = 2 };
PointClass c2 = c1; // KOPIUJE tylko REFERENCJĘ - c1 i c2 wskazują na TEN SAM obiekt
c2.X = 100;
Console.WriteLine(c1.X); // 100 - c1 TEŻ się zmieniło! To ten sam obiekt
Console.WriteLine(c2.X); // 100
To jest fundamentalna różnica, o której trzeba pamiętać - przypisanie struct kopiuje cały obiekt, przypisanie class kopiuje tylko referencję.
To samo dotyczy przekazywania do metod
void ModifyStruct(Point p) { p.X = 999; } // otrzymuje KOPIĘ
var point = new Point { X = 1 };
ModifyStruct(point);
Console.WriteLine(point.X); // 1 - oryginał niezmieniony, metoda dostała kopię
void ModifyClass(PointClass c) { c.X = 999; } // otrzymuje REFERENCJĘ do tego samego obiektu
var pointClass = new PointClass { X = 1 };
ModifyClass(pointClass);
Console.WriteLine(pointClass.X); // 999 - oryginał ZMIENIONY, bo to ta sama referencja
Wyjątek - przekazanie przez ref:
void ModifyStructByRef(ref Point p) { p.X = 999; }
var point = new Point { X = 1 };
ModifyStructByRef(ref point);
Console.WriteLine(point.X); // 999 - TERAZ się zmieniło, bo przekazaliśmy referencję do struktury
Wbudowane typy .NET, które są struct - częściej używasz ich niż myślisz
Większość prymitywnych typów w C# to w rzeczywistości struct:
int, double, decimal, bool, char, DateTime, TimeSpan, Guid // WSZYSTKIE to struct!
int a = 5;
int b = a; // kopiowanie przez wartość - dokładnie ta sama semantyka co Point wyżej
b = 10;
Console.WriteLine(a); // 5 - niezmienione
To wyjaśnia, dlaczego int/double/bool zawsze zachowują się "intuicyjnie" (kopiowanie wartości) - bo to structy, tak jak Twój własny Point.
Domyślna wartość - struct nie może być null (bez Nullable<T>)
Point p; // ✅ OK, ma DOMYŚLNĄ wartość (X=0, Y=0) - struct NIE MOŻE być "niezainicjalizowany" jako null
p = null; // ❌ Błąd kompilacji - struct nie jest referencyjny, nie może być null
PointClass c; // deklaracja bez wartości - ale UŻYCIE bez przypisania to błąd kompilacji
c = null; // ✅ OK - class może być null, bo to referencja
Żeby struct mógł reprezentować "brak wartości", potrzebujesz Nullable<T> (składnia Point?):
Point? maybePoint = null; // ✅ teraz OK - Nullable<Point>
if (maybePoint.HasValue) { var p = maybePoint.Value; }
Dziedziczenie - struct NIE wspiera (poza interfejsami)
public struct Point : IComparable<Point> // ✅ MOŻE implementować interfejsy
{
public int CompareTo(Point other) => 0;
}
public struct ColoredPoint : Point { } // ❌ Błąd kompilacji - struct NIE MOŻE dziedziczyć po innym struct
Każdy struct niejawnie dziedziczy po System.ValueType (który z kolei dziedziczy po object), i to jest koniec hierarchii - nie da się z niego dalej dziedziczyć, ani samemu dziedziczyć po innym struct. To jest zresztą powód, dla którego record struct (o którym mówiliśmy) nie może mieć hierarchii dziedziczenia, w przeciwieństwie do record class.
Kiedy używać struct - praktyczna reguła (Microsoft Guidelines)
Microsoft rekomenduje struct gdy wszystkie poniższe warunki są spełnione:
- Reprezentuje pojedynczą wartość, koncepcyjnie podobną do prymitywów (int, DateTime) - np. Point, Money, Coordinates
- Ma mały rozmiar (rekomendowane do 16 bajtów - większe struktury tracą zaletę wydajnościową przy kopiowaniu)
- Jest niemutowalna (albo przynajmniej projektowana z myślą o tym)
- Nie musisz często "boxować" jej do object/interfejsu (patrz niżej o boxing)
// Dobry kandydat na struct - mały, wartość, niemutowalny
public readonly struct Money
{
public decimal Amount { get; }
public string Currency { get; }
public Money(decimal amount, string currency) { Amount = amount; Currency = currency; }
}
readonly struct (C# 7.2+) - kompilator wymusza niemutowalność wszystkich pól, co pozwala na dodatkowe optymalizacje (kompilator wie, że nie musi robić defensywnych kopii przy każdym dostępie).
Dlaczego NIE nadużywać struct - koszt kopiowania
public struct BigStruct // ŹLE - za duży struct
{
public int Field1, Field2, Field3, Field4, Field5, Field6, Field7, Field8, Field9, Field10;
// 40 bajtów - każde przekazanie do metody KOPIUJE wszystkie 40 bajtów
}
void ProcessMany(List<BigStruct> items)
{
foreach (var item in items) // KAŻDA iteracja kopiuje 40 bajtów struktury
{
DoSomething(item); // KOLEJNA kopia przy przekazaniu do metody
}
}
Dla dużych struktur, częste kopiowanie (przy przekazywaniu do metod, przy iteracji) staje się droższe niż użycie class (gdzie kopiuje się tylko małą referencję, niezależnie od rozmiaru obiektu). To jest powód limitu "do 16 bajtów" w wytycznych Microsoftu.
Boxing - koszt przy używaniu struct jako object/interfejsu
Point p = new Point { X = 1, Y = 2 };
object boxed = p; // BOXING - struct zostaje "opakowany" i skopiowany NA STERTĘ
IComparable<Point> comparable = p; // TEŻ boxing, jeśli Point implementuje interfejs
Boxing to kosztowna operacja - struct, który normalnie żyje na stosie, zostaje skopiowany na stertę i opakowany jako obiekt referencyjny, żeby mógł być traktowany jako object/interfejs. To jest coś, czego class nigdy nie robi (bo już jest na stercie).
List<object> list = new List<object>();
for (int i = 0; i < 1000; i++)
{
list.Add(i); // KAŻDE dodanie int (struct) do List<object> to BOXING - 1000 alokacji na stercie!
}
To jest zresztą powód, dla którego generyczne kolekcje (List<int> zamiast List<object>, albo List<T> w ogóle) są tak ważne w .NET - unikają boxing dla typów wartościowych.
record struct - łączenie obu światów
public record struct PointDto(int X, int Y);
To jest dokładnie struct (semantyka pamięciowa: kopiowanie przez wartość, stos) plus automatycznie generowany Equals/GetHashCode/ToString (semantyka record) - najlepsze z obu, dla małych, niemutowalnych danych.
Tabela porównawcza struct vs class
struct |
class |
|
|---|---|---|
| Typ | Wartościowy | Referencyjny |
| Gdzie żyje | Stos (zwykle) / inline w obiekcie | Sterta |
| Przypisanie/przekazanie | Kopiuje CAŁY obiekt | Kopiuje tylko referencję |
Może być null |
Nie (bez Nullable<T>/?) |
Tak |
| Dziedziczenie | Nie (tylko interfejsy) | Tak (jedna klasa bazowa) |
| Domyślna wartość | Zainicjalizowana zerami (nie null) | null |
| Koszt przy dużym rozmiarze | Rośnie (kopiowanie) | Stały (kopiuje tylko referencję) |
| Boxing przy użyciu jako object/interfejs | Tak (kosztowne) | Nie (już na stercie) |
| Typowe zastosowanie | Małe, niemutowalne wartości (Point, Money, DateTime) |
Encje, serwisy, obiekty z tożsamością/zachowaniem |
Pytanie-pułapka na rozmowie
"Czy struct może mieć metody?" - Tak, i to jest częste zaskoczenie dla osób kojarzących struct wyłącznie z C/C++ (gdzie to "goła" struktura danych bez zachowania). W C# struct może mieć metody, właściwości, konstruktory (ale nie bezparametrowy jawny do C# 10 - jest zawsze niejawny, zerujący pola), implementować interfejsy - różni się od class głównie semantyką pamięciową (wartość vs referencja) i brakiem dziedziczenia, nie brakiem możliwości posiadania logiki.