如果您试图在C#中使用通用字典，就像在另一种语言中使用关联数组一样：

foreach(var item in myDictionary)
{
  foo(item.Key);
  bar(item.Value);
}

或者，如果只需要遍历密钥集合，请使用

foreach(var item in myDictionary.Keys)
{
  foo(item);
}

最后，如果你只对价值观感兴趣：

foreach(var item in myDictionary.Values)
{
  foo(item);
}

（请注意，var关键字是可选的C#3.0及以上版本的特性，您也可以在此处使用键/值的确切类型）

在某些情况下，您可能需要由for循环实现提供的计数器。为此，LINQ提供了启用以下功能的ElementAt：

for (int index = 0; index < dictionary.Count; index++) {
  var item = dictionary.ElementAt(index);
  var itemKey = item.Key;
  var itemValue = item.Value;
}

从C#7开始，您可以将对象分解为变量。我认为这是遍历字典的最佳方式。

例子：

在KeyValuePair<TKey，TVal>上创建一个扩展方法，对其进行解构：

public static void Deconstruct<TKey, TVal>(this KeyValuePair<TKey, TVal> pair, out TKey key, out TVal value)
{
   key = pair.Key;
   value = pair.Value;
}

按以下方式遍历任何字典<TKey，TVal>

// Dictionary can be of any types, just using 'int' and 'string' as examples.
Dictionary<int, string> dict = new Dictionary<int, string>();

// Deconstructor gets called here.
foreach (var (key, value) in dict)
{
   Console.WriteLine($"{key} : {value}");
}

foreach(KeyValuePair<string, string> entry in myDictionary)
{
    // do something with entry.Value or entry.Key
}

我将利用.NET 4.0+的优势，为最初接受的问题提供更新的答案：

foreach(var entry in MyDic)
{
    // do something with entry.Value or entry.Key
}

我很感激这个问题已经得到了很多回应，但我想做一点研究。

与在数组等对象上迭代相比，在字典上迭代可能会相当慢。在我的测试中，对数组的迭代耗时0.015003秒，而对字典（元素数量相同）的迭代耗时0.0365073秒，是其2.4倍！尽管我看到了更大的差异。相比之下，List介于0.00215043秒之间。

然而，这就像比较苹果和橙子。我的观点是迭代字典很慢。

字典是为查找而优化的，因此考虑到这一点，我创建了两种方法。一个简单地执行foreach，另一个迭代键然后查找。

public static string Normal(Dictionary<string, string> dictionary)
{
    string value;
    int count = 0;
    foreach (var kvp in dictionary)
    {
        value = kvp.Value;
        count++;
    }

    return "Normal";
}

这一个加载键并对其进行迭代（我也尝试将键拉入字符串[]，但差异可以忽略不计。

public static string Keys(Dictionary<string, string> dictionary)
{
    string value;
    int count = 0;
    foreach (var key in dictionary.Keys)
    {
        value = dictionary[key];
        count++;
    }

    return "Keys";
}

在本例中，正常的foreach测试花费0.0310062，密钥版本花费0.2205441。加载所有键并迭代所有查找显然要慢很多！

在最后一次测试中，我已经执行了十次迭代，看看使用这里的键是否有任何好处（此时我只是好奇）：

这是RunTest方法，如果它可以帮助您可视化正在发生的事情。

private static string RunTest<T>(T dictionary, Func<T, string> function)
{            
    DateTime start = DateTime.Now;
    string name = null;
    for (int i = 0; i < 10; i++)
    {
        name = function(dictionary);
    }
    DateTime end = DateTime.Now;
    var duration = end.Subtract(start);
    return string.Format("{0} took {1} seconds", name, duration.TotalSeconds);
}

这里，正常的foreach运行耗时0.2820564秒（大约是单个迭代耗时的十倍——正如您所预期的那样）。按键的迭代耗时2.2249449秒。

编辑添加：阅读其他一些答案让我怀疑如果我使用字典而不是字典会发生什么。在本例中，数组耗时0.0120024秒，列表耗时0.0185037秒，字典耗时0.0465093秒。可以合理地预期，数据类型会对字典的速度产生影响。

我的结论是什么？

如果可以的话，请避免在字典上进行迭代，因为它们比在具有相同数据的数组上进行迭代要慢得多。如果您确实选择遍历字典，不要太聪明，尽管速度较慢，但可能会比使用标准foreach方法做得更糟。