在 C# 中迭代​​字典

Posted 2023-02-22

【中文标题】在 C# 中迭代​​字典

【英文标题】：Iterating a dictionary in C#

【发布时间】：2012-07-16 18:43:00

【问题描述】：

var dict = new Dictionary<int, string>();
for (int i = 0; i < 200000; i++)
    dict[i] = "test " + i;

我使用下面的代码迭代了这个字典：

foreach (var pair in dict)
    Console.WriteLine(pair.Value);

然后，我用这个迭代它：

foreach (var key in dict.Keys)
    Console.WriteLine(dict[key]);

第二次迭代减少了约 3 秒。 我可以通过这两种方法获取键和值。我想知道的是第二种方法是否有缺点。由于我可以找到的the most rated question 不包括这种迭代字典的方式，所以我想知道为什么没有人使用它以及它如何更快地工作。

【问题讨论】：

我不喜欢您为此使用控制台。如果您切换两者并在另一个之前测试dict.Keys 方法会发生什么？

@Blindy 考虑到字典的大小，我应该想象控制台不会产生影响（即，任何输出缓冲都会在两者之间产生影响），但值得查看生成的 IL 看看有什么不同

在我的测试中，第二种方法（访问dict[key]）速度较慢。调用 Console.WriteLine（执行 I/O）所花费的时间可能会主导此性能测试并影响您对枚举的测量。

@d4wn，是的，你应该避免任何你无法控制的事情，并且 IO 被框架缓冲，再次被 Windows 缓冲，可能有也可能没有显卡延迟从强制重绘等上传新数据，如果您认为您正在测量字典性能，这会欺骗您:)

您还应该注意微优化。你的代码真的处于一个额外的几毫秒真的很重要的位置吗？这当然是可能的，但仍有可能您的程序已经足够好，或者有更好的代码 sn-ps 需要优化。

【参考方案1】：

你的时间测试有一些根本性的缺陷：

Console.Writeline 是一种 I/O 操作，它所花费的时间比内存访问和 CPU 计算多几个数量级。迭代时间的任何差异可能与此操作的成本相比相形见绌。这就像在铸铁炉子里量硬币的重量一样。 你没有提到整个操作花了多长时间，所以说一个比另一个少 3 秒是没有意义的。如果第一次运行需要 300 秒，第二次运行需要 303 秒，那么您就是在进行微优化。 你没有提到你是如何测量运行时间的。运行时间是否包括加载和引导程序集的时间？ 您没有提到可重复性：您是否多次运行这些操作？几百次？不同的顺序？

这是我的测试。请注意我如何尽我最大的努力确保迭代方法是唯一发生变化的事情，并且我包含一个控件来查看纯粹因为 for 循环和分配而占用了多少时间：

void Main()

    // Insert code here to set up your test: anything that you don't want to include as
    // part of the timed tests.
    var dict = new Dictionary<int, string>();
    for (int i = 0; i < 2000; i++)
        dict[i] = "test " + i;
    string s = null;
    var actions = new[]
    
        new TimedAction("control", () => 
        
    for (int i = 0; i < 2000; i++)
            s = "hi";
        ),
        new TimedAction("first", () => 
        
            foreach (var pair in dict)
            s = pair.Value;
        ),
        new TimedAction("second", () => 
        
            foreach (var key in dict.Keys)
            s = dict[key];
        )
    ;
    TimeActions(100, // change this number as desired.
        actions);



#region timer helper methods
// Define other methods and classes here
public void TimeActions(int iterations, params TimedAction[] actions)

    Stopwatch s = new Stopwatch();
    foreach(var action in actions)
    
        var milliseconds = s.Time(action.Action, iterations);
        Console.WriteLine("0: 1ms ", action.Message, milliseconds);
    



public class TimedAction

    public TimedAction(string message, Action action)
    
        Message = message;
        Action = action;
    
    public string Message get;private set;
    public Action Action get;private set;


public static class StopwatchExtensions

    public static double Time(this Stopwatch sw, Action action, int iterations)
    
        sw.Restart(); 
        for (int i = 0; i < iterations; i++)
        
            action();
        
        sw.Stop();

        return sw.Elapsed.TotalMilliseconds;
    

#endregion

结果

控制：1.2173ms 第一：9.0233ms 秒：18.1301ms

所以在这些测试中，使用索引器所花费的时间大约是迭代键值对的两倍，这正是我所期望的*。如果我将条目数和重复数增加一个数量级，这大致保持成比例，如果我以相反的顺序运行这两个测试，我会得到相同的结果。

* 为什么我会期待这个结果？ Dictionary 类可能在内部将其条目表示为 KeyValuePairs，因此当您直接迭代它时，它真正要做的就是遍历其数据结构一次，将每个条目交给调用者。如果您仅迭代 Keys，它仍然需要找到每个 KeyValuePair，并从中为您提供 Key 属性的值，因此仅此一步的成本就与迭代大致相同首先穿过它。然后你必须调用索引器，它必须计算提供的键的哈希值，跳转到正确的哈希表存储桶，并对在那里找到的任何 KeyValuePairs 的键进行相等性检查。这些操作并不是非常昂贵，但是一旦你做了 N 次，它的代价就和你再次迭代内部哈希表结构一样昂贵。

【讨论】：

只是好奇，你为什么会这样？我预计时间的增加不会超过 100%。

@NominSim 首先，您实际上是按顺序从数组中获取每一项。在第二个中，您正在单独访问每个项目。它需要计算每个项目的哈希码，它需要在数组中找到那个项目，它可能没有按顺序访问内存（导致更多的缓存未命中，因为字典足够大，无法放入缓存），并且函数类的开销更大。只是列出一些事情。说了这么多，我也认为会比 100% 增加一点点。

我发现这很有用。我一直在寻找更可取的答案，“foreach（Dict 中的 kvp）”或“foreach（Dict.keys 中的键）”，我最初发现了这个较老的问题 - ***.com/questions/141088/… - 但这个讨论帮助我说服了 100 %。

@Ben：首先：字典针对恒定时间插入和删除进行了优化，因此他们可能没有使用数组来跟踪插入顺序：他们更有可能使用一个链表结构，在迭代它时有更多的开销。遍历数组列表大约需要控件的 3 倍时间：链表大约是 4 倍。第二：这些都是非常快速的操作，所以每一个小操作都会有所作为。 pair.Value 实际上占了其余部分。如果您创建一个new LinkedList<KeyValuePair>(dict) 并在第三次测试中对其进行迭代，结果是相似的。

@Ben：进一步考虑这一点，我还想到KeyValuePair 是一个结构，因此在传递时需要复制其内容。 pair.Value 实际上可以忽略不计（事实上，它可能会被完全优化掉），但迭代 new LinkedList<string>(dict.Values) 与 new LinkedList<KeyValuePair>(dict) 之间存在很大差异。感谢您提出发人深省的问题。