用C#语言迭代字典


Iterating a dictionary in C#

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

我用下面的代码迭代了这本词典：

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

然后，我使用下面的代码迭代它：

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

第二次迭代的时间减少了约3秒。我可以通过这两种方法同时获得键和值。我想知道第二种方法是否有缺点。因为我能找到的关于这个的最有评价的问题不包括这种迭代字典的方法，所以我想知道为什么没有人使用它，以及它是如何更快地工作的。

相关讨论

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

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

这是我的测试。请注意，我如何尽最大努力确保迭代方法是唯一会发生变化的方法，并且我包括一个控件，以查看纯粹由于for循环和赋值而占用了多少时间：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
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}: {1}ms", 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

结果

control: 1.2173ms
first: 9.0233ms
second: 18.1301ms

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

*为什么我会期待这个结果？Dictionary类可能在内部将其条目表示为keyValuePairs，因此当您直接迭代它时，它真正需要做的就是遍历它的数据结构一次，并在调用方到达它时将每个条目都处理掉。如果只迭代键，那么它仍然需要找到每个keyValuePair，并从中为您提供Key属性的值，因此单靠这一步的成本与首先迭代它的成本大致相同。然后，您必须调用索引器，索引器必须为提供的键计算哈希，跳转到正确的哈希表存储桶，并对它在其中找到的任何键值对的键进行相等性检查。这些操作并不是非常昂贵，但是一旦您执行了n次，它的开销就相当于您再次遍历内部哈希表结构的开销。

相关讨论