Take the 2-minute tour ×

How do I enumerate a dictionary?

Suppose I use foreach() for dictionay enumeration. I can't update a key/value pair inside foreach(). So I want some other method.

share|improve this question
If my answer helped you solve your problem, consider accepting it as the answer to help direct other users. –  Ian Jun 20 '13 at 11:52

4 Answers 4

To enumerate a dictionary you either enumerate the values within it:

Dictionary<int, string> dic;

foreach(string s in dic.Values)

or the KeyValuePairs

foreach(KeyValuePair<int, string> kvp in dic)
   Console.WriteLine("Key : " + kvp.Key.ToString() + ", Value : " + kvp.Value);

or the keys

foreach(int key in dic.Keys)

If you wish to update the items within the dictionary you need to do so slightly differently, because you can't update the instance while enumerating. What you'll need to do is enumerate a different collection that isn't being updated, like so:

Dictionary<int, string> newValues = new Dictionary<int, string>() { 1, "Test" };
foreach(KeyValuePair<int, string> kvp in newValues)
   dic[kvp.Key] = kvp.Value; // will automatically add the item if it's not there

To remove items, do so in a similar way, enumerating the collection of items we want to remove rather than the dictionary itself.

List<int> keys = new List<int>() { 1, 3 };
foreach(int key in keys)
share|improve this answer
Or you can enumerate the keys. –  strager Mar 24 '09 at 11:57
Indeed! Thanks for pointing that out. –  Ian Mar 24 '09 at 12:21
I'd expect that enumerating the keys would be more common than enumerating only the values (at least it has been in my experience), since you can find the value for the key quite easily (that being the point of the dictionary). –  Wedge Mar 24 '09 at 16:25
This covers the enumeration but not the update. To update, you'll need to use one of the methods below... see spender's answer. –  Edyn Nov 14 '11 at 22:12

In answer to the problem "I can't update value/key inside foreach()", you cannot modify a collection while enumerating it. I would approach this by making a copy of the Keys collection:


//...fill the dictionary

int[] keys = dic.Keys.ToArray();
foreach (int i in keys)
share|improve this answer
No need for .ToArray() AFAIK. .Keys returns an IEnumerable. –  strager Mar 24 '09 at 11:58
sure, but if the dictionary is altered in the loop, what happens to that enumeration? it changes, surely? –  spender Mar 24 '09 at 12:08
changing the line: foreach(int i in keys) to foreach(int i in dic.keys) throws and InvalidOperationException, "Collection was modified; enumeration operation may not execute." Making a copy, as above does not fail in this way. –  spender Mar 24 '09 at 13:01
You can still do it inline, just add .ToArray()... so foreach(int i in dic.Keys.ToArray()) –  Edyn Nov 14 '11 at 22:10
Sure, you can do it inline, but it's the same thing at the end of the day. In the optimized release binary, it probably gets inlined anyway. On separate lines, it's easier to debug if something goes wrong. –  spender Nov 14 '11 at 23:06

Foreach. There are three ways: You can enumerate over the Keys property, over the Values property or over the dictionary itself which is an enumerator of KeyValuePair<TKey, TValue>.

share|improve this answer

I just answered the same (updated) question for lists, so here's the same thing for dictionaries.

public static void MutateEach(this IDictionary<TKey, TValue> dict, Func<TKey, TValue, KeyValuePair<TKey, TValue>> mutator)
    var removals = new List<TKey>();
    var additions = new List<KeyValuePair<TKey, TValue>>();

    foreach (var pair in dict)
        var newPair = mutator(pair.Key, pair.Value);
        if ((newPair.Key != pair.Key) || (newPair.Value != pair.Value))

    foreach (var removal in removals)

    foreach (var addition in additions)
        dict.Add(addition.Key, addition.Value);

Note that we have to do the updates outside the loop, so we aren't modifying the dictionary as we enumerate it. Also this detects clashes caused by making two keys the same - it will throw (due to the use of Add).

Example - make all keys lowercase and trim all values, with a Dictionary<string, string>:

myDict.MutateEach(key => key.ToLower(), value => value.Trim());

If the keys are not unique when made lowercase, this will throw.

share|improve this answer

Your Answer


