C#比较dynamic和Dictionary性能

开发中需要传递变参，考虑使用 dynamic 还是
Dictionary（准确地说是Dictionary<string,object>）。dynamic 的编码体验显著优于
Dictionary，如果性能差距不大的话，我会选择使用dynamic。搜索后没有找到类似对比数据，决定自行实验。

首先使用以下测试代码:

1. public void TestDynamic() 
2. { 
3.     var e = CallDynamic(new { Value = 0 }); 
4.     int v = e.Value; 
5. } 
6.  
7. public void TestDictionary() 
8. { 
9.     var dict = new Dictionary<string, object>(); 
10.     dict["Value"] = 0; 
11.     dict = CallDictionary(dict); 
12.     int v = (int)dict["Value"]; 
13. } 
14.  
15. private dynamic CallDynamic(dynamic test) 
16. { 
17.     int v = test.Value; 
18.     v++; 
19.     return new { Value = v }; 
20. } 
21.  
22. private Dictionary<string, object> CallDictionary( 
23.     Dictionary<string, object> test) 
24. { 
25.     int v = (int)test["Value"]; 
26.     v++; 
27.     var dict = new Dictionary<string, object>(); 
28.     dict["Value"] = v; 
29.     return dict; 
30. } 

分别比较运行 1次、10次、100次、1000次、1e4次、1e5次、1e6次 时间
结果：

其中dynamic列和dynamic2列的数据分别是：

在一次运行中执行一步测试 和 在一次运行中连续执行所有测试

分析测试过程和数据，得到以下结论：

1.dynamic首次使用会产生一定的性能损耗
2.无论是否首次使用，使用次数达到一定量级，dynamic性能一定优于Dictionary
3.一次运行中连续使用dynamic会显著拉低平均性能损耗

考虑到传递变参可能出现多个参数，以上测试不完全。

使用以下代码进行第二阶段实验：

1. public void InvokeDynamic() 
2. { 
3.     var e = CallDynamic2( 
4.         new { Value1 = 0, Value2 = 0L, Value3 = 0f, Value4 = 0.0, Value5 = "test" }); 
5.     int v1 = e.Value1; 
6.     long v2 = e.Value2; 
7.     float v3 = e.Value3; 
8.     double v4 = e.Value4; 
9.     string v5 = e.Value5; 
10. } 
11.  
12. public void InvokeDictionary() 
13. { 
14.     var dict = new Dictionary<string, object>(); 
15.     dict["Value1"] = 0; 
16.     dict["Value2"] = 0L; 
17.     dict["Value3"] = 0f; 
18.     dict["Value4"] = 0.0; 
19.     dict["Value5"] = "test"; 
20.     dict = CallDictionary2(dict); 
21.     int v1 = (int)dict["Value1"]; 
22.     long v2 = (long)dict["Value2"]; 
23.     float v3 = (float)dict["Value3"]; 
24.     double v4 = (double)dict["Value4"]; 
25.     string v5 = (string)dict["Value5"]; 
26. } 
27.  
28. private dynamic CallDynamic2(dynamic test) 
29. { 
30.     int v1 = test.Value1; 
31.     long v2 = test.Value2; 
32.     float v3 = test.Value3; 
33.     double v4 = test.Value4; 
34.     string v5 = test.Value5; 
35.     v1++; 
36.     v2++; 
37.     v3++; 
38.     v4++; 
39.     v5 += "test"; 
40.     return new { Value1 = v1, Value2 = v2, Value3 = v3, Value4 = v4, Value5 = v5 }; 
41. } 
42.  
43. private Dictionary<string, object> CallDictionary2( 
44.     Dictionary<string, object> test) 
45. { 
46.     int v1 = (int)test["Value1"]; 
47.     long v2 = (long)test["Value2"]; 
48.     float v3 = (float)test["Value3"]; 
49.     double v4 = (double)test["Value4"]; 
50.     string v5 = (string)test["Value5"]; 
51.     v1++; 
52.     v2++; 
53.     v3++; 
54.     v4++; 
55.     v5 += "test"; 
56.     var dict = new Dictionary<string, object>(); 
57.     dict["Value1"] = v1; 
58.     dict["Value2"] = v2; 
59.     dict["Value3"] = v3; 
60.     dict["Value4"] = v4; 
61.     dict["Value5"] = v5; 
62.     return dict; 
63. } 

结果数据：

最后决定选择使用dynamic

有兄弟考虑可能Box损耗了性能导致Dictionary表现不佳，
专门做了第三阶段实验，对比dynamic和Dictionary<string,long>

具体数据不贴了，结果是dynamic在100000量级快一倍

来源：51CTO