C# Collections Überblick: List, Dictionary & HashSet einfach erklärt

Stell dir vor, du sitzt in deinem ersten richtigen Projekt - ob als Azubi, im Studium oder im ersten Job - und sollst eine Kundenliste verwalten. Ein Array klingt erst mal logisch, bis der Kunde meint: „Können Sie mal eben einen Kunden ergänzen?" Genau hier scheitern Arrays, denn ihre Größe ist fest. Collections in C# lösen genau dieses Problem: Sie wachsen dynamisch mit deinen Daten und bieten dir für jeden Anwendungsfall das passende Werkzeug. Dieser C# Collections Überblick stellt dir die drei wichtigsten Vertreter vor: List, Dictionary und HashSet.

Was sind Collections in C#?

Collections sind Klassen zum Speichern und Verwalten von Objektgruppen. Im Gegensatz zu Arrays können sie ihre Größe zur Laufzeit ändern und bringen fertige Methoden zum Hinzufügen, Suchen und Löschen mit.

Die wichtigsten Collections liegen im Namespace System.Collections.Generic. Das Wort generic (generisch) bedeutet: Du legst beim Erstellen fest, welchen Typ die Collection speichert - etwa `List<string>` für Texte oder `List<int>` für Zahlen. Der Compiler prüft dann alles für dich, und du musst nicht mehr casten.

Neben `List`, `Dictionary` und `HashSet` gibt es übrigens noch `Queue<T>` (Warteschlange), `Stack<T>` (Stapel) und `LinkedList<T>`. Für den Alltag und die IHK-Prüfung sind aber die drei folgenden am wichtigsten - eine komplette Übersicht findest du bei Microsoft Learn.

Wie funktioniert die List<T>?

Die List<T> ist deine Standard-Collection: eine geordnete, dynamische Liste von Elementen. Stell dir eine Einkaufsliste vor: Du notierst alles untereinander, die Reihenfolge bleibt erhalten, und du kannst jederzeit etwas durchstreichen oder ergänzen.

List<string> einkaufsliste = new List<string>();
einkaufsliste.Add("Brot");
einkaufsliste.Add("Milch");
einkaufsliste.Add("Kaffee");

Console.WriteLine(einkaufsliste[0]);    // "Brot" - Zugriff per Index
Console.WriteLine(einkaufsliste.Count); // 3

einkaufsliste.Remove("Milch");
bool vorhanden = einkaufsliste.Contains("Kaffee"); // true

Merke: Eine `List<T>` behält die Einfügereihenfolge, erlaubt Duplikate und erlaubt den Zugriff per Index - wie ein Array, nur flexibel.

Wenn du mit `foreach` durch die Liste läufst, nutzt du übrigens automatisch das `IEnumerable`-Interface. Wie das genau funktioniert, erklären wir im Beitrag IEnumerable und foreach in C# verstehen.

Wie funktioniert das Dictionary<TKey, TValue>?

Das Dictionary<TKey, TValue> speichert Paare aus einem eindeutigen Schlüssel und einem zugehörigen Wert. Das Prinzip kennst du von einem Wörterbuch: Du suchst unter einem Stichwort (Key) und findest sofort die Erklärung (Value).

// Schluessel: Kundennummer, Wert: Name
Dictionary<int, string> kunden = new Dictionary<int, string>();
kunden.Add(1, "Anna Mueller");
kunden[2] = "Ben Schmidt"; // Alternative Schreibweise

Console.WriteLine(kunden[1]);   // "Anna Mueller"
Console.WriteLine(kunden.Count); // 2

// Sicher abfragen ohne Absturz:
if (kunden.TryGetValue(3, out string name))
{
  Console.WriteLine(name);
}
else
{
  Console.WriteLine("Kundennummer 3 existiert nicht.");
}

Merke: Der Zugriff über den Schlüssel ist extrem schnell - im Schnitt O(1), egal ob 10 oder 10 Millionen Einträge drin sind. Dafür darf jeder Schlüssel nur einmal vorkommen.

Wann brauchst du ein HashSet<T>?

Das HashSet<T> ist eine ungeordnete Menge, in der jedes Element maximal einmal vorkommen darf. Stell dir eine Gästeliste vor: Egal wie oft jemand versucht, sich doppelt einzutragen - es zählt nur einmal.

HashSet<string> besucher = new HashSet<string>();
besucher.Add("anna@example.com");
besucher.Add("ben@example.com");

bool hinzugefuegt = besucher.Add("anna@example.com");
Console.WriteLine(hinzugefuegt);      // false - war schon drin
Console.WriteLine(besucher.Count);    // 2, nicht 3

bool enthalten = besucher.Contains("ben@example.com"); // true

Die große Stärke ist die Geschwindigkeit der `Contains`-Prüfung: im Schnitt O(1) - konstant schnell. Bei einer `List` ist sie O(n), das heißt: Die Liste muss im schlimmsten Fall komplett durchsucht werden. Details zur Klasse findest du in der offiziellen Dokumentation.

Merke: Willst du nur prüfen, „ist X schon vorhanden?", nimm ein `HashSet<T>`. Willst du zusätzlich Daten zu X ablegen, nimm ein `Dictionary<TKey, TValue>`.

C# Collections Überblick: Welche Collection passt wann?

Kurz gesagt: `List<T>` für Reihenfolge, `Dictionary` für Zuordnungen, `HashSet` für Eindeutigkeit.

Die Wahl der richtigen Collection entscheidest du anhand von drei Fragen: Brauchst du eine Reihenfolge? Willst du Duplikate erlauben? Und greifst du über einen Index oder einen Schlüssel zu?

Praxisbeispiel: Kleine Teilnehmerverwaltung

Hier ein vollständiges, lauffähiges Programm, das alle drei Collections kombiniert - typisch für kleinere Übungsaufgaben in Ausbildung, Studium oder Berufseinstieg:

using System;
using System.Collections.Generic;

class Programm
{
  static void Main()
  {
    // List: Reihenfolge der Anmeldung
    List<string> teilnehmer = new List<string>();
    teilnehmer.Add("Anna");
    teilnehmer.Add("Ben");
    teilnehmer.Add("Clara");

    // Dictionary: Punkte pro Teilnehmer
    Dictionary<string, int> punkte = new Dictionary<string, int>();
    punkte["Anna"] = 92;
    punkte["Ben"] = 78;
    punkte["Clara"] = 85;

    // HashSet: Eindeutige E-Mail-Adressen
    HashSet<string> emails = new HashSet<string>();
    emails.Add("anna@beispiel.de");
    emails.Add("ben@beispiel.de");
    emails.Add("anna@beispiel.de"); // wird ignoriert (Duplikat)

    foreach (string name in teilnehmer)
    {
      Console.WriteLine(name + ": " + punkte[name] + " Punkte");
    }
    Console.WriteLine("Eindeutige E-Mails: " + emails.Count); // 2
  }
}

Häufige Fehler, die Anfänger machen

Diese drei Stolperfallen tauchen bei Einsteigern immer wieder auf - merks du sie dir früh, sparst du dir später viel Debugging-Zeit.

Fehler 1: KeyNotFoundException beim Dictionary. Greifst du mit `kunden["Max"]` auf einen nicht vorhandenen Schlüssel zu, stürzt das Programm ab.

// Falsch: crasht, wenn "Max" fehlt
string wert = kunden["Max"];

// Richtig: sicher pruefen
if (kunden.TryGetValue("Max", out string name))
{
  Console.WriteLine(name);
}

Fehler 2: Doppelte Schlüssel bei `Add`. Ruft du `kunden.Add(1, "Neu")` auf, obwohl der Schlüssel 1 schon existiert, fliegt eine `ArgumentException`. Die Index-Schreibweise `kunden[1] = "Neu"` überschreibt dagegen einfach - merk dir den Unterschied.

Fehler 3: `List.Contains` bei riesigen Datenmengen. Prüfst du in einer Schleife tausendfach, ob etwas in einer Liste steht, wird das mit `List<T>` zäh (O(n) pro Prüfung). Ein `HashSet<T>` ist hier um Größenordnungen schneller. Das gilt allerdings nicht, wenn du gleichzeitig die Reihenfolge brauchst - dann führt kein Weg an der `List` vorbei.

Übungstipp: Wörter zählen

Nimm einen beliebigen Satz als String, zerlege ihn mit `Split(' ')` in Wörter und zähle mit einem `Dictionary<string, int>`, wie oft jedes Wort vorkommt. Diese Aufgabe taucht ständig in Übungen und Vorstellungsgesprächen auf - und sie zwingt dich, `TryGetValue` oder `ContainsKey` sinnvoll einzusetzen. Erweiterung für Fortgeschrittene: Filtere Duplikate aus dem Eingabetext mit einem `HashSet<string>`, bevor du zählst.

FAQ: Häufige Fragen zu C# Collections

Was ist der Unterschied zwischen List und Array?

Ein Array hat eine feste Größe (`string[] namen = new string[3];`), eine `List<T>` wächst dynamisch. Im Alltag nutzt du deshalb fast immer die List.

Wann nutze ich ein Dictionary statt einer List?

Sobald du Daten über einen eindeutigen Schlüssel finden willst - etwa eine Kundennummer oder einen Benutzernamen. Die Suche ist dann direkt, ohne die ganze Collection zu durchsuchen.

Was ist schneller: List.Contains oder HashSet.Contains?

`HashSet.Contains` ist im Schnitt O(1), `List.Contains` ist O(n). Bei vielen Prüfvorgängen gewinnt das HashSet klar.

Warum brauchen eigene Klassen als Dictionary-Key Equals und GetHashCode?

Das Dictionary findet Einträge über den Hash-Wert des Schlüssels. Überschreibst du `Equals` und `GetHashCode` in deiner Klasse nicht, vergleicht das Dictionary nur Referenzen. Mehr dazu im Artikel C# ToString Equals GetHashCode: Object-Methoden erklärt.

Gibt es noch weitere Collections?

Ja - etwa `Queue<T>` (First In, First Out), `Stack<T>` (Last In, First Out) und `SortedList`. Für den Einstieg reichen List, Dictionary und HashSet aber völlig aus.

Fazit

Collections sind das Fundament fast jedes C#-Programms: Die List<T> für geordnete Daten, das Dictionary<TKey, TValue> für Zuordnungen über eindeutige Schlüssel und das HashSet<T> für Eindeutigkeit und schnelle Existenzprüfungen. Wenn du diese drei beherrschst, kannst du die meisten Alltagssituationen - von der IHK-Abschlussprüfung bis zum ersten beruflichen Projekt - souverän lösen. Der offizielle Einstiegspunkt dazu ist die Dokumentation zu Collections bei Microsoft Learn.

Und falls du bei C# oder anderen IT-Themen festhängst: Bei study-it.education findest du individuelle Nachhilfe - genau abgestimmt auf Ausbildung, Studium und Berufseinstieg. Schau vorbei, wir bringen dich weiter!