取决于你是在寻找关键点还是值。。。

来自MSDN Dictionary（TKey，TValue）类描述：

// When you use foreach to enumerate dictionary elements,
// the elements are retrieved as KeyValuePair objects.
Console.WriteLine();
foreach( KeyValuePair<string, string> kvp in openWith )
{
    Console.WriteLine("Key = {0}, Value = {1}", 
        kvp.Key, kvp.Value);
}

// To get the values alone, use the Values property.
Dictionary<string, string>.ValueCollection valueColl =
    openWith.Values;

// The elements of the ValueCollection are strongly typed
// with the type that was specified for dictionary values.
Console.WriteLine();
foreach( string s in valueColl )
{
    Console.WriteLine("Value = {0}", s);
}

// To get the keys alone, use the Keys property.
Dictionary<string, string>.KeyCollection keyColl =
    openWith.Keys;

// The elements of the KeyCollection are strongly typed
// with the type that was specified for dictionary keys.
Console.WriteLine();
foreach( string s in keyColl )
{
    Console.WriteLine("Key = {0}", s);
}

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

与在数组等对象上迭代相比，在字典上迭代可能会相当慢。在我的测试中，对数组的迭代耗时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方法做得更糟。

使用C#7，将此扩展方法添加到解决方案的任何项目中：

public static class IDictionaryExtensions
{
    public static IEnumerable<(TKey, TValue)> Tuples<TKey, TValue>(
        this IDictionary<TKey, TValue> dict)
    {
        foreach (KeyValuePair<TKey, TValue> kvp in dict)
            yield return (kvp.Key, kvp.Value);
    }
}

使用这个简单的语法

foreach (var(id, value) in dict.Tuples())
{
    // your code using 'id' and 'value'
}

或者这个，如果你喜欢的话

foreach ((string id, object value) in dict.Tuples())
{
    // your code using 'id' and 'value'
}

代替传统的

foreach (KeyValuePair<string, object> kvp in dict)
{
    string id = kvp.Key;
    object value = kvp.Value;

    // your code using 'id' and 'value'
}

扩展方法将IDictionary＜TKey，TValue＞的KeyValuePair转换为强类型元组，允许您使用这种新的舒适语法。

它只将所需的字典条目转换为元组，因此不会将整个字典转换为元组。因此，不存在与此相关的性能问题。

与直接使用KeyValuePair相比，调用扩展方法来创建元组的成本很低，如果您要将KeyValuePail的财产Key和Value分配给新的循环变量，那么这应该不是问题。

实际上，这种新语法非常适合大多数情况，除了低级别的超高性能场景，在这种情况下，您仍然可以选择不在特定位置使用它。

看看这个：MSDN博客-C#7中的新功能

正如在这个答案中已经指出的，KeyValuePair＜TKey，TValue＞实现了一个从.NET Core 2.0、.NET Standard 2.1和.NET Framework 5.0（预览版）开始的解构方法。

这样，就可以以KeyValuePair不可知的方式遍历字典：

var dictionary = new Dictionary<int, string>();

// ...

foreach (var (key, value) in dictionary)
{
    // ...
}

我写了一个扩展来遍历字典。

public static class DictionaryExtension
{
    public static void ForEach<T1, T2>(this Dictionary<T1, T2> dictionary, Action<T1, T2> action) {
        foreach(KeyValuePair<T1, T2> keyValue in dictionary) {
            action(keyValue.Key, keyValue.Value);
        }
    }
}

然后你可以打电话

myDictionary.ForEach((x,y) => Console.WriteLine(x + " - " + y));

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