C# Dictionary iterieren: KeyValuePair & foreach einfach erklärt

Stell dir vor, du sitzt in deiner Abschlussprüfung als Fachinformatiker oder im ersten Projekt beim Arbeitgeber: Du hast ein `Dictionary` mit 50 Benutzernamen und deren Punktestand - und sollst alle Einträge auf der Konsole ausgeben. Wenn du bis jetzt nur mit `List`-Objekten gearbeitet hast, fragst du dich zu Recht: Wie komme ich eigentlich an die Daten da drin? Die Antwort ist einfacher als gedacht: C# Dictionary iterieren läuft auf `foreach` in Kombination mit `KeyValuePair` hinaus - und genau das schauen wir uns jetzt an.

Was ist ein Dictionary in C#?

Ein Dictionary (`Dictionary<TKey, TValue>`) ist eine Collection aus Schlüssel-Wert-Paaren. Jeder Wert hat einen eindeutigen Schlüssel - wie ein Wörterbuch, bei dem du über das Wort (Key) die Übersetzung (Value) findest. Einen ausführlichen Überblick über Dictionary, List und HashSet findest du in unserem Artikel zu C# Collections.

var punkte = new Dictionary<string, int>
{
  { "anna", 92 },
  { "ben", 78 },
  { "clara", 88 }
};

// Direkter Zugriff ueber den Schluessel
Console.WriteLine(punkte["anna"]); // Ausgabe: 92

Der direkte Zugriff über den Schlüssel ist extrem schnell - egal ob 3 oder 3 Millionen Einträge drin sind. Aber manchmal willst du eben alle Einträge durchgehen. Genau dafür brauchst du das Iterieren.

Wie iterierst du über ein C# Dictionary?

Dictionary-Iteration bedeutet, alle Schlüssel-Wert-Paare nacheinander zu durchlaufen - in C# am häufigsten mit einer `foreach`-Schleife über `KeyValuePair<TKey, TValue>`-Objekte.

Ein `KeyValuePair` ist eine kleine Struktur, die genau zwei Dinge speichert: `.Key` und `.Value` (Details in den Microsoft Learn Docs zu KeyValuePair).

var punkte = new Dictionary<string, int>
{
  { "anna", 92 },
  { "ben", 78 },
  { "clara", 88 }
};

foreach (KeyValuePair<string, int> eintrag in punkte)
{
  Console.WriteLine($"{eintrag.Key}: {eintrag.Value} Punkte");
}

Die Ausgabe:

anna: 92 Punkte
ben: 78 Punkte
clara: 88 Punkte

Warum `KeyValuePair` und nicht einfach zwei Variablen? Weil ein Dictionary-Eintrag aus genau diesen zwei Teilen besteht. Die Schleife liefert dir pro Durchlauf ein komplettes Paar, und du greifst mit `eintrag.Key` und `eintrag.Value` auf beide Teile zu.

Tipp: Nutze `var` für weniger Schreibarbeit

Statt des langen Typs `KeyValuePair<string, int>` kannst du `var` verwenden. Der Compiler weiß sowieso, welcher Typ kommt:

foreach (var eintrag in punkte)
{
  Console.WriteLine($"{eintrag.Key}: {eintrag.Value}");
}

Merke: `foreach (var eintrag in dict)` liefert dir pro Durchlauf ein `KeyValuePair` mit `.Key` und `.Value`.

Wie durchläufst du nur Keys oder nur Values?

Dafür bietet das Dictionary zwei Eigenschaften: `.Keys` und `.Values`. Manchmal brauchst du nämlich nur die Schlüssel oder nur die Werte - dann sparst du dir das komplette Paar.

// Nur die Schluessel
foreach (string name in punkte.Keys)
{
  Console.WriteLine(name);
}

// Nur die Werte, z.B. fuer eine Summe
int gesamt = 0;
foreach (int wert in punkte.Values)
{
  gesamt += wert;
}
Console.WriteLine($"Gesamt: {gesamt} Punkte"); // 258

Welche Variante du wann nutzt, zeigt diese Übersicht:

Praxisbeispiel: Lagerbestand auswerten

Hier ein vollständiges, lauffähiges Programm - z.B. für ein kleines Inventur-Tool. Es zeigt alle drei Iterationsvarianten im Zusammenspiel:

using System;
using System.Collections.Generic;

class Programm
{
  static void Main()
  {
    var lagerbestand = new Dictionary<string, int>
    {
      { "Tastatur", 15 },
      { "Maus", 42 },
      { "Monitor", 7 },
      { "USB-Kabel", 120 }
    };

    // 1. Komplette Eintraege ausgeben
    Console.WriteLine("Lageruebersicht:");
    foreach (var artikel in lagerbestand)
    {
      Console.WriteLine($"- {artikel.Key}: {artikel.Value} Stueck");
    }

    // 2. Gesamtbestand berechnen (nur Values noetig)
    int gesamt = 0;
    foreach (int anzahl in lagerbestand.Values)
    {
      gesamt += anzahl;
    }
    Console.WriteLine($"Gesamtbestand: {gesamt} Artikel");

    // 3. Artikel unter Mindestbestand finden
    foreach (var artikel in lagerbestand)
    {
      if (artikel.Value < 10)
      {
        Console.WriteLine($"Nachbestellen: {artikel.Key}");
      }
    }
  }
}

Wenn du das ausführst, siehst du die Übersicht, den Gesamtbestand von 184 Artikeln und die Nachbestell-Empfehlung für "Monitor". Genau solche Aufgaben kommen in Prüfungen und kleinen betrieblichen Tools ständig vor.

Welche Fehler solltest du beim Dictionary-Iterieren vermeiden?

Drei Fehler begegnen uns ständig - in Prüfungen genauso wie im Berufsalltag. Jeder davon lässt sich leicht vermeiden, wenn du ihn kennst.

Fehler 1: Dictionary während der Schleife verändern

Das ist der Klassiker. Fügst du Einträge hinzu oder entfernst sie innerhalb von `foreach`, wirft C# eine `InvalidOperationException` - die Schleife würde sonst über veränderte Daten laufen und die Ergebnisse wären unvorhersehbar.

// FALSCH: Crash zur Laufzeit
foreach (var eintrag in punkte)
{
  if (eintrag.Value < 80)
  {
    punkte.Remove(eintrag.Key); // InvalidOperationException!
  }
}

Die Lösung: Erst eine Kopie der Schlüssel erstellen, dann löschen:

// RICHTIG: Kopie der Keys durchlaufen
foreach (string schluessel in punkte.Keys.ToList())
{
  if (punkte[schluessel] < 80)
  {
    punkte.Remove(schluessel);
  }
}

Dafür brauchst du `using System.Linq;` am Dateianfang. Wie du mit LINQ filterst und komplett neue Collections erzeugst, erklären wir im Artikel zu C# LINQ.

Fehler 2: Nicht vorhandene Schlüssel mit `[]` abfragen

Der Zugriff mit eckigen Klammern wirft eine KeyNotFoundException, wenn der Schlüssel fehlt. Gerade beim Iterieren passiert das schnell, wenn Schlüssel aus verschiedenen Quellen kommen. Sicherer ist `TryGetValue`:

if (punkte.TryGetValue("david", out int wert))
{
  Console.WriteLine($"david hat {wert} Punkte");
}
else
{
  Console.WriteLine("david existiert nicht");
}

Fehler 3: Sich auf die Reihenfolge verlassen

Ein `Dictionary` garantiert keine Einfügereihenfolge. Wenn du sortierte Ausgaben brauchst, musst du selbst sortieren - etwa mit `OrderBy` aus LINQ:

foreach (var eintrag in punkte.OrderBy(e => e.Value))
{
  Console.WriteLine($"{eintrag.Key}: {eintrag.Value}");
}

Merke: Verändere niemals ein Dictionary während des Iterierens - und verlasse dich nie auf dessen Reihenfolge.

Übungstipp: Wörterzähler selbst bauen

Nimm einen beliebigen deutschen Satz als String, splitte ihn mit `Split(' ')` in Wörter und zähle mit einem `Dictionary<string, int>`, wie oft jedes Wort vorkommt. Für jedes Wort prüfst du mit `ContainsKey`, ob es schon existiert - wenn ja, zählst du den Wert hoch, wenn nein, fügst du es hinzu. Zum Schluss iterierst du über alle Einträge und gibst die Statistik aus.

Diese Übung kombiniert alle Techniken aus diesem Artikel und ist ein beliebtes Prüfungsthema. Mehr Hintergrund zu `foreach` und `IEnumerable` findest du in unserem Artikel zu IEnumerable und foreach in C# sowie in den offiziellen C#-Docs zu Iterationsanweisungen.

FAQ: Häufige Fragen zum C# Dictionary iterieren

Wie iteriere ich über ein Dictionary in C#?

Mit einer `foreach`-Schleife: `foreach (var eintrag in dict)`. Jeder `eintrag` ist ein `KeyValuePair` mit den Eigenschaften `.Key` und `.Value`. Alternativ iterierst du gezielt über `dict.Keys` oder `dict.Values`.

Was ist ein KeyValuePair in C#?

Eine einfache Struktur mit genau zwei Eigenschaften: `Key` und `Value`. Beim Durchlaufen eines Dictionaries liefert die `foreach`-Schleife pro Durchlauf genau ein solches Paar zurück.

Kann ich die Reihenfolge der Dictionary-Einträge beeinflussen?

Nein, ein `Dictionary<TKey, TValue>` garantiert keine Reihenfolge. Für sortierte Ausgaben nutze `OrderBy` aus LINQ oder wechsle zu `SortedDictionary<TKey, TValue>`.

Warum crasht meine Schleife mit InvalidOperationException?

Weil du das Dictionary während der Iteration verändert hast - durch `Add` oder `Remove`. Erstelle vorher eine Kopie (z.B. `dict.Keys.ToList()`) und verändere das Original nur außerhalb der eigentlichen Dictionary-Schleife.

Gibt es auch eine for-Schleife für Dictionaries?

Indirekt ja: `dict.ElementAt(i)` in einer `for`-Schleife oder vorheriges Umwandeln mit `dict.ToList()`. Das ist aber langsamer und nur sinnvoll, wenn du wirklich einen Index brauchst - `foreach` ist der Standardweg.

Fazit

C# Dictionary iterieren heißt: `foreach` über `KeyValuePair` - mit `.Key` und `.Value` kommst du an beide Bestandteile jedes Eintrags. Merk dir die drei Zugriffswege (komplettes Paar, `.Keys`, `.Values`), verändere das Dictionary nie während der Schleife und vertraue nie auf die Reihenfolge. Wer das beherrscht, kann eine der wichtigsten Collections in C# voll ausreizen - Details dazu findest du in der offiziellen Dictionary-Dokumentation auf Microsoft Learn.

Wenn du bei C#, Prüfungsdruck oder deinen ersten Projektwochen Unterstützung brauchst: Die Nachhilfe-Lehrer von study-it.education coachen Azubis, Studenten und Berufseinsteiger individuell - vom Dictionary bis zur Abschlussprüfung.