Stack & Heap in C#

Wie werden Daten im Speicher verwaltet?

🎯 Ja! int ist ein struct!

int ist nur ein Alias (Kurzform) für System.Int32

Und System.Int32 ist definiert als:

public struct Int32 : IComparable, IFormattable, IConvertible { // ... interne Implementierung }

💡 Das bedeutet:

  • ✓ Alle primitiven Typen (int, bool, double, etc.) sind structs
  • ✓ Sie sind Value Types
  • ✓ Sie werden auf dem Stack gespeichert
  • ✓ Beim Zuweisen wird der Wert kopiert

🔬 Der Beweis

Alle primitiven Typen als struct

struct Boolean // bool struct Byte // byte struct SByte // sbyte struct Int16 // short struct UInt16 // ushort struct Int32 // int struct UInt32 // uint struct Int64 // long struct UInt64 // ulong struct Single // float struct Double // double struct Decimal // decimal struct Char // char

Auch diese sind structs:

struct DateTime struct TimeSpan struct Guid struct IntPtr struct Nullable<T> // Deine eigenen: struct Point struct Vector3 struct Color

📌 Zusammenfassung

✓ int, bool, double etc. sind alle structs

✓ Sie sind im System-Namespace definiert

✓ C# Keywords wie int sind nur Aliase (Kurzformen)

✓ int x = 10; ist das Gleiche wie System.Int32 x = 10;

✓ Alle sind Value Types → Stack-Speicherung

📚

Stack

LIFO (Last In, First Out)

Top → int z = 30;
int y = 20;
int x = 10;
↓ Stack wächst nach unten
✓ Sehr schnell - automatische Verwaltung
✓ Begrenzte Größe (ca. 1 MB Standard)
✓ Automatisches Aufräumen bei Scope-Ende
✓ Thread-spezifisch - jeder Thread hat eigenen Stack

Was wird gespeichert?

  • • Value Types (int, bool, struct, etc.)
  • • Lokale Variablen
  • • Methoden-Parameter
  • • Rücksprungadressen von Methoden
🗂️

Heap

Dynamischer Speicher

0x001A → Person { Name="Max", Age=25 }
0x002B → List<int> { 1, 2, 3, ... }
0x003C → string "Hello World"
Beliebige Reihenfolge
✓ Großer Speicher - für große Objekte
✓ Garbage Collector räumt automatisch auf
✓ Langsamer als Stack
✓ Shared - alle Threads teilen Heap

Was wird gespeichert?

  • • Reference Types (class, interface, delegate)
  • • Objekte
  • • Arrays
  • • Strings

🎨 Visualisierung: Wo landet was?

Code:

int x = 10; string name = "Max"; Person p = new Person();

Stack:

p = 0x002B → Zeiger auf Heap
name = 0x001A → Zeiger auf Heap
x = 10 Direkter Wert

Heap:

0x002B: Person { ... }
0x001A: "Max"

💡 Wichtig:

int x wird direkt auf dem Stack gespeichert.
string name und Person p speichern nur die Adresse (Referenz) auf dem Stack, das eigentliche Objekt liegt im Heap!

📋 Alle Value Types in C#

🔢 Ganzzahlen

byte 0 bis 255
sbyte -128 bis 127
short ±32K
ushort 0 bis 65K
int ±2.1 Mrd
uint 0 bis 4.3 Mrd
long ±9 Trillionen
ulong 0 bis 18 Trill.

💰 Kommazahlen

float 7 Stellen
double 15-16 Stellen
decimal 28-29 Stellen

decimal für Geld verwenden! Genauer bei Finanzen.

🎯 Andere

bool true/false
char 1 Zeichen
DateTime Datum/Zeit
enum Aufzählung
struct Eigene!

📌 System-Typen (Aliase)

In C# sind die bekannten Typen nur Aliase für System-Typen:

int = System.Int32
bool = System.Boolean
string = System.String
decimal = System.Decimal

🔗 Reference Types (Heap)

Standard Reference Types

  • class - Alle Klassen
  • string - Text (speziell!)
  • object - Basisklasse
  • interface - Schnittstellen
  • delegate - Funktionszeiger
  • dynamic - Dynamischer Typ

Collections & Arrays

  • Array - int[], string[], etc.
  • List<T> - Dynamische Liste
  • Dictionary<K,V> - Key-Value
  • Queue<T> - Warteschlange
  • Stack<T> - Stapel

⚠️ Besonderheit: string

string ist ein Reference Type (liegt im Heap), verhält sich aber wie ein Value Type (immutable = unveränderlich)!

💻 Praktisches Beispiel

void Example() { // Value Types → Stack int age = 25; // Auf Stack bool isActive = true; // Auf Stack decimal price = 19.99m; // Auf Stack // Reference Types → Heap (Referenz auf Stack) string name = "Max"; // Referenz auf Stack, "Max" im Heap Person person = new Person(); // Referenz auf Stack, Objekt im Heap int[] numbers = new int[5]; // Referenz auf Stack, Array im Heap // Struct (eigener Value Type) → Stack Point p = new Point(10, 20); // Komplett auf Stack }

📚 Auf dem Stack:

  • ✓ age = 25
  • ✓ isActive = true
  • ✓ price = 19.99
  • ✓ name = 0x001A (Adresse)
  • ✓ person = 0x002B (Adresse)
  • ✓ numbers = 0x003C (Adresse)
  • ✓ p = { X=10, Y=20 }

🗂️ Im Heap:

  • ✓ 0x001A: "Max"
  • ✓ 0x002B: Person { ... }
  • ✓ 0x003C: int[5] { 0,0,0,0,0 }

⚡ Performance-Tipps

✅ Gut:

  • • Kleine Datenstrukturen als struct
  • • Value Types für Performance-kritische Bereiche
  • • readonly struct für Immutability
  • • Lokale Variablen (Stack ist schnell!)

❌ Vermeiden:

  • • Große structs (Boxing/Unboxing teuer)
  • • Unnötige Objekt-Erstellung
  • • Zu viele Heap-Allokationen in Schleifen
  • • struct-Arrays wenn Objekte groß sind

🎯 Quick Quiz

Wo wird int x = 42; gespeichert?