C# bietet eine umfangreiche Auswahl an Collection-Typen in System.Collections.Generic zum Speichern von Datengruppen. Die häufigsten sind List<T> (dynamisches Array), Dictionary<K,V> (Schlüssel-Wert-Map) und HashSet<T> (eindeutige Menge). Die Wahl des richtigen Typs ist wichtig für Klarheit und Leistung.
var numbers = new List<int> { 1, 2, 3 };
numbers.Add(4); // grows dynamically
numbers[0]; // index access — O(1)
numbers.Contains(3); // O(n) search
numbers.Remove(2);
numbers.Count; // size
foreach (var n in numbers) { } // iterate
List<T> ist die universelle Standardkollektion — eine geordnete, größenveränderbare, indizierte Liste. Das <T> ist ein generischer Typparameter (List<string>, List<User>), der Typensicherheit zur Compile-Zeit bietet.
var ages = new Dictionary<string, int> { ["Ann"] = 30, ["Bob"] = 25 };
ages["Carol"] = 28; // add/set
ages["Ann"]; // get by key — O(1)
ages.ContainsKey("Ann");
ages.TryGetValue("Ann", out var age); // safe lookup (no exception if missing)
foreach (var (name, a) in ages) { } // iterate key-value pairs
Dictionary<K,V> ordnet Schlüsseln Werte mit schnellen O(1)-Suchen zu — für Caches, Indizes und jeden schlüsselbasierten Zugriff. TryGetValue ist die sichere Möglichkeit zur Suche (um eine Ausnahme zu vermeiden, wenn der Schlüssel fehlt).
var set = new HashSet<int> { 1, 2, 3 }; // unique elements, O(1) Contains
set.Add(2); // ignored (duplicate)
var queue = new Queue<int>(); // FIFO
var stack = new Stack<int>(); // LIFO
int[] arr = { 1, 2, 3 }; // fixed-size array
var ro = numbers.AsReadOnly(); // read-only wrapper
Ordered, indexed, resizable → List<T>
Key-value lookup (fast) → Dictionary<K,V>
Uniqueness / fast membership → HashSet<T>
FIFO / LIFO processing → Queue<T> / Stack<T>
Fixed size / performance-critical → array (T[])
Collections sind grundlegend für fast jedes Programm — das Speichern und Verarbeiten von Datengruppen ist konstant — daher ist das Verständnis der häufigen Collection-Typen von C# und das richtige Auswahlverfahren wesentliches alltägliches Wissen.
Die Kenntnis der Haupttypen und ihrer Anwendungsfälle — List<T> für geordnete, indizierte, größenveränderbare Daten (das universelle Arbeitspferd), Dictionary<K,V> für schnelle schlüsselbasierte Suche (Caches, Indizes), HashSet<T> für Eindeutigkeit und schnelle Mitgliedschaftstests sowie Queue/Stack für FIFO/LIFO-Verarbeitung — ist notwendig zum Schreiben effizienter, klarer Code.
Die Wahl hat direkten Einfluss auf Leistung (z. B. die O(1)-Suche eines Dictionary gegenüber dem Durchsuchen einer List mit O(n), oder HashSet's O(1)-Mitgliedschaft gegenüber List's O(n)) und Absicht, daher ist die Wahl der passenden Collection statt standardmäßiger Verwendung von List<T> für alles eine wichtige Fähigkeit.
Diese Collections sind auch generisch (<T>), was Typensicherheit zur Compile-Zeit bietet.
Das Wissen um praktische Details wie TryGetValue für sichere Dictionary-Suchen (um Ausnahmen bei fehlenden Schlüsseln zu vermeiden) und die Leistungsmerkmale jedes Typs deckt die alltäglichen Anforderungen beim Arbeiten mit Daten in C# ab.
Da Collections praktisch in jedem Programm vorkommen und die richtige Wahl die Leistung und Lesbarkeit bedeutsam beeinflusst, ist die Beherrschung der häufigen Collection-Typen und ihrer angemessenen Verwendung grundlegendes, unverzichtbares Wissen für effektive C#-Entwicklung.