How to Iterate Over a Dictionary in C#

By the end of this page, you will understand the standard way to iterate over a Dictionary<TKey, TValue> in C#, how to access keys and values, when to use foreach with KeyValuePair, and which common patterns developers use in real projects.

A dictionary in C# stores data as key-value pairs. Each key is unique, and each key maps to one value.

When you iterate over a dictionary, the most common goal is one of these:

• read both the key and the value
• read only the keys
• read only the values

The standard way to iterate over a dictionary is with foreach. A Dictionary<TKey, TValue> is enumerable, so you can loop through it directly.

When you do that, each item is a KeyValuePair<TKey, TValue>. That means each loop iteration gives you:

• item.Key
• item.Value

Example:

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

In modern C#, var is also common:

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

Think of a dictionary like a set of labeled drawers.

• The key is the label on the drawer.
• The value is what is stored inside.

When you iterate over the whole dictionary, you walk past each drawer and see both the label and the contents.

When you iterate over .Keys, you only read the labels.

When you iterate over .Values, you only inspect the contents.

So the question is simple: what information do you need while looping?

• Need both label and content? Loop through the dictionary.
• Need only labels? Loop through Keys.
• Need only contents? Loop through Values.

That is the mental shortcut most developers use.

Standard way: iterate over key-value pairs

var scores = new Dictionary<string, int>
{
    { "Alice", 95 },
    { "Bob", 87 },
    { "Charlie", 91 }
};

foreach (var pair in scores)
{
    Console.WriteLine($"{pair.Key} => {pair.Value}");
}

This is the most common and recommended approach when you need both the key and the value.

Iterate over only keys

foreach (var key in scores.Keys)
{
    Console.WriteLine(key);
}

Use this when only the keys matter.

Iterate over only values

foreach (var value in scores.Values)
{
    Console.WriteLine(value);
}

Use this when only the values matter.

Deconstruction syntax

In modern C#, you can deconstruct key-value pairs:

Consider this code:

var scores = new Dictionary<string, int>
{
    { "Alice", 95 },
    { "Bob", 87 }
};

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

Step by step:

1. A dictionary named scores is created.
2. It contains two entries:
   • key "Alice" with value 95
   • key "Bob" with value 87
3. The foreach loop starts.
4. On the first iteration, pair represents one key-value pair, for example:
   • pair.Key is "Alice"
   • pair.Value is 95

Configuration settings

var settings = new Dictionary<string, string>
{
    { "Theme", "Dark" },
    { "Language", "en-US" },
    { "Region", "US" }
};

foreach (var (key, value) in settings)
{
    Console.WriteLine($"{key} = {value}");
}

Useful for printing, validating, or exporting app settings.

Counting occurrences

var wordCounts = new Dictionary<string, int>
{
    { "apple", 3 },
    { "banana", 5 }
};

foreach (var (word, count) in wordCounts)
{
    Console.WriteLine($"{word} appears {count} times");
}

Common in text analysis and reporting.

API or JSON-like field processing

Some applications map field names to values for dynamic processing.

In real codebases, developers usually choose the loop style based on what they need.

Common pattern: iterate over the whole dictionary

Use this when you need both key and value.

foreach (var (userId, userName) in users)
{
    logger.LogInformation($"User {userId}: {userName}");
}

Common pattern: validation

foreach (var (field, value) in formData)
{
    if (string.IsNullOrWhiteSpace(value))
    {
        Console.WriteLine($"Missing value for {field}");
    }
}

This is common in request validation and data cleaning.

Common pattern: guard clause before lookup or processing

if (scores.Count == 0)
{
    return;
}

foreach (var (name, score) in scores)
{
    Console.WriteLine($"{name}: {score}");
}

Common pattern: use TryGetValue instead of iterating for one key

1. Iterating over keys when you really need both key and value

Broken or less clear approach:

foreach (var key in scores.Keys)
{
    Console.WriteLine($"{key}: {scores[key]}");
}

This works, but if you need both key and value, iterating over the dictionary directly is clearer.

Better:

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

2. Expecting a guaranteed order

Beginners sometimes assume the items will always come out in a specific order.

foreach (var pair in scores)
{
    Console.WriteLine(pair.Key);
}

Do not build logic that depends on order unless you use a collection type intended for ordered behavior.

3. Modifying the dictionary during foreach

Broken example:

foreach (var pair in scores)
{
     (pair.Value < )
    {
        scores.Remove(pair.Key);
    }
}

Quick reference

Iterate over key-value pairs

foreach (var pair in dictionary)
{
    Console.WriteLine(pair.Key);
    Console.WriteLine(pair.Value);
}

Iterate over keys only

foreach (var key in dictionary.Keys)
{
    Console.WriteLine(key);
}

Iterate over values only

foreach (var value in dictionary.Values)
{
    Console.WriteLine(value);
}

Deconstruct pairs

foreach (var (key, value) in dictionary)
{
    Console.WriteLine($"{key}: {value}");
}

Look up one key

if (dictionary.TryGetValue("someKey", out var value))
{
    Console.WriteLine();
}

Is foreach the standard way to iterate over a dictionary in C#?

Yes. foreach is the normal and recommended way to iterate over a Dictionary<TKey, TValue>.

What type do I get when I loop over a dictionary?

Each item is a KeyValuePair<TKey, TValue>, so you can access .Key and .Value.

Should I loop over Keys and then use dictionary[key]?

Only if you truly only need keys. If you need both key and value, iterating over the dictionary directly is usually clearer.

Can I use a for loop with a dictionary?

Not naturally. Dictionaries are not index-based collections, so foreach is the better fit.

Can I change the dictionary while looping through it?

Not safely with a normal foreach. Adding or removing entries during enumeration can cause an exception.

How do I get just one value from a dictionary?

Use TryGetValue instead of iterating through every item.

Is deconstruction a good way to iterate?

• Dictionary<TKey, TValue>: The collection type being iterated.
• foreach loop: The standard C# loop for enumerating collections.
• KeyValuePair<TKey, TValue>: The type returned for each dictionary entry.
• TryGetValue: Better for retrieving one value by key.
• ContainsKey: Useful when checking whether a key exists.
• List<T>: Helpful for comparing index-based collections with dictionaries.
• LINQ: Commonly used with dictionaries for filtering and projection.
• Collection iteration: The broader concept behind looping over arrays, lists, and dictionaries.