由浅入深CIL系列:6.For和Foreach的CIL结构组成以及运行效率

             本节即将新接触的CIL操作符如下：

             br.s        IL_003c    无条件地将控制转移到目标指令（短格式）

             clt          从计算堆栈的顶部弹出当前值并将其存储到索引 2 处的局部变量列表中

             ldloca.s   CS$5$0001 将位于特定索引处的局部变量的地址加载到计算堆栈上（短格式）

             leave.s    退出受保护的代码区域，无条件将控制转移到目标指令（缩写形式）
             constrained.   约束要对其进行虚方法调用的类型

             endfinally   将控制从异常块的 fault 或 finally 子句转移回公共语言结构 (CLI) 异常处理程序

        在C#中我们经常会遇到遍历数组、遍历List<>、遍历HashTable等情况，在本文中我们首先构造一个List<int>对象，然后通过For和Foreach来遍历它看看他们之间的CIL代码有什么区别和不同。

        首先我们贴出C#代码如下：

 

1. class Program 
2. { 
3. static void Main(string[] args) 
4. { 
5. //初始化一个List<int> 
6. List<int> listInt = new List<int>(); 
7. for (int i = 0; i < 100000; i++) 
8. { 
9. listInt.Add(i + 1); 
10. } 
11. Console.WriteLine("--------------------------"); 
12. //第一种for遍历 
13. for (int i = 0; i < listInt.Count; i++) 
14. { 
15. } 
16.  
17. //第二种foreach遍历 
18. foreach (int i in listInt) 
19. { 
20. } 
21.  
22. } 
23. } 

        其次我们来看CIL代码如下所示，因为CIL代码有点儿长，设置为隐藏有需要的可以点击查看：

所有的CIL代码

1. .method private hidebysig static void Main(string[] args) cil managed 
2. { 
3. .entrypoint 
4. // 代码大小 123 (0x7b) 
5. .maxstack 3 
6. .locals init ([0] class [mscorlib]System.Collections.Generic.List`1<int32> listInt, 
7. [1] int32 i, 
8. [2] bool CS$4$0000, 
9. [3] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32> CS$5$0001) 
10. IL_0000: nop 
11. IL_0001: newobj instance void class [mscorlib]System.Collections.Generic.List`1<int32>::.ctor() 
12. IL_0006: stloc.0 
13. IL_0007: ldc.i4.0 
14. IL_0008: stloc.1 
15. IL_0009: br.s IL_001b 
16. IL_000b: nop 
17. IL_000c: ldloc.0 
18. IL_000d: ldloc.1 
19. IL_000e: ldc.i4.1 
20. IL_000f: add 
21. IL_0010: callvirt instance void class [mscorlib]System.Collections.Generic.List`1<int32>::Add(!0) 
22. IL_0015: nop 
23. IL_0016: nop 
24. IL_0017: ldloc.1 
25. IL_0018: ldc.i4.1 
26. IL_0019: add 
27. IL_001a: stloc.1 
28. IL_001b: ldloc.1 
29. IL_001c: ldc.i4 0x186a0 
30. IL_0021: clt 
31. IL_0023: stloc.2 
32. IL_0024: ldloc.2 
33. IL_0025: brtrue.s IL_000b 
34. IL_0027: ldstr "--------------------------" 
35. IL_002c: call void [mscorlib]System.Console::WriteLine(string) 
36. IL_0031: nop 
37. IL_0032: ldc.i4.0 
38. IL_0033: stloc.1 
39. IL_0034: br.s IL_003c 
40. IL_0036: nop 
41. IL_0037: nop 
42. IL_0038: ldloc.1 
43. IL_0039: ldc.i4.1 
44. IL_003a: add 
45. IL_003b: stloc.1 
46. IL_003c: ldloc.1 
47. IL_003d: ldloc.0 
48. IL_003e: callvirt instance int32 class [mscorlib]System.Collections.Generic.List`1<int32>::get_Count() 
49. IL_0043: clt 
50. IL_0045: stloc.2 
51. IL_0046: ldloc.2 
52. IL_0047: brtrue.s IL_0036 
53. IL_0049: nop 
54. IL_004a: ldloc.0 
55. IL_004b: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<!0> class [mscorlib]System.Collections.Generic.List`1<int32>::GetEnumerator() 
56. IL_0050: stloc.3 
57. .try 
58. { 
59. IL_0051: br.s IL_005d 
60. IL_0053: ldloca.s CS$5$0001 
61. IL_0055: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::get_Current() 
62. IL_005a: stloc.1 
63. IL_005b: nop 
64. IL_005c: nop 
65. IL_005d: ldloca.s CS$5$0001 
66. IL_005f: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext() 
67. IL_0064: stloc.2 
68. IL_0065: ldloc.2 
69. IL_0066: brtrue.s IL_0053 
70. IL_0068: leave.s IL_0079 
71. } // end .try 
72. finally 
73. { 
74. IL_006a: ldloca.s CS$5$0001 
75. IL_006c: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32> 
76. IL_0072: callvirt instance void [mscorlib]System.IDisposable::Dispose() 
77. IL_0077: nop 
78. IL_0078: endfinally 
79. } // end handler 
80. IL_0079: nop 
81. IL_007a: ret 
82. } // end of method Program::Main 

        再次我们来分析这个CIL代码，他分为三大部分，第一部分为List的初始化，第二部分为For循环遍历List，第二部分为Foreach遍历循环，首先我们看for循环的CIL代码如下所示：

1. //第一种for遍历 
2. IL_0031: nop 
3. //将整数值 0 作为 int32 推送到计算堆栈上 
4. IL_0032: ldc.i4.0 
5. //从计算堆栈的顶部弹出当前值并将其存储到索引 1 处的局部变量列表中 
6. IL_0033: stloc.1 
7. //无条件地将控制转移到目标指令（短格式）。 
8. IL_0034: br.s IL_003c 
9. IL_0036: nop 
10. ///注意：这里就是循环内部需要处理的代码处，在本实例中无代码 
11. IL_0037: nop 
12. //将索引 1 处的局部变量加载到计算堆栈上 
13. IL_0038: ldloc.1 
14. //将整数值 1 作为 int32 推送到计算堆栈上 
15. IL_0039: ldc.i4.1 
16. //将两个值相加并将结果推送到计算堆栈上。 
17. IL_003a: add 
18. //从计算堆栈的顶部弹出当前值并将其存储到索引 1 处的局部变量列表中 
19. IL_003b: stloc.1 
20. //将索引 1 处的局部变量加载到计算堆栈上 
21. IL_003c: ldloc.1 
22. //将索引 0 处的局部变量加载到计算堆栈上 
23. IL_003d: ldloc.0 
24. //调用系统函数获取List数量 
25. IL_003e: callvirt instance int32 class [mscorlib]System.Collections.Generic.List`1<int32>::get_Count() 
26. //比较两个值。如果第一个值小于第二个值，则将整数值 1 (int32) 推送到计算堆栈上；反之，将 0 (int32) 推送到计算堆栈上。 
27. IL_0043: clt 
28. //从计算堆栈的顶部弹出当前值并将其存储到索引 2 处的局部变量列表中 
29. IL_0045: stloc.2 
30. //将索引 2 处的局部变量加载到计算堆栈上 
31. IL_0046: ldloc.2 
32. //如果 value 为 true、非空或非零，则将控制转移到目标指令（短格式）。 
33. IL_0047: brtrue.s IL_0036 

        下面我们来看看Foreach方式的遍历的CIL代码如下：

1. //第二种foreach遍历 
2. IL_0049: nop 
3. //将索引 0 处的局部变量加载到计算堆栈上。 
4. IL_004a: ldloc.0 
5. //调用List<int> listInt对象的GetEnumerator()方法 
6. //任何集合类对象都有一个GetEnumerator()方法，该方法可以返回一个实现了 IEnumerator接口的对象， 
7. //这个返回的IEnumerator对象既不是集合类对象，也不是集合的元素类对象，它是一个独立的类对象。 
8. //通过这个对象，可以遍历访问集合类对象中的每一个元素对象 . 
9. IL_004b: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<!0> class [mscorlib]System.Collections.Generic.List`1<int32>::GetEnumerator() 
10. //从计算堆栈的顶部弹出当前值并将其存储到索引 3 处的局部变量列表中 
11. IL_0050: stloc.3 
12. .try 
13. { 
14. //无条件地将控制转移到目标指令（短格式）。 
15. IL_0051: br.s IL_005d 
16. //将位于特定索引处的局部变量的地址加载到计算堆栈上（短格式）。 
17. IL_0053: ldloca.s CS$5$0001 
18. //调用get_Current()函数返回一个Object类型。 
19. IL_0055: call instance !0 valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::get_Current() 
20. //从计算堆栈的顶部弹出当前值并将其存储到索引 1 处的局部变量列表中 
21. IL_005a: stloc.1 
22. IL_005b: nop 
23. ///注意：这里就是循环内部需要处理的代码处，在本实例中无代码 
24. IL_005c: nop 
25. //将位于特定索引处的局部变量的地址加载到计算堆栈上（短格式）。 
26. IL_005d: ldloca.s CS$5$0001 
27. //调用MoveNext()函数运行到下一个元素 
28. IL_005f: call instance bool valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext() 
29. //从计算堆栈的顶部弹出当前值并将其存储到索引 2 处的局部变量列表中 
30. IL_0064: stloc.2 
31. //将索引 2 处的局部变量加载到计算堆栈上 
32. IL_0065: ldloc.2 
33. //如果 value 为 true、非空或非零，则将控制转移到目标指令（短格式）。 
34. IL_0066: brtrue.s IL_0053 
35. //退出受保护的代码区域，无条件将控制转移到目标指令（缩写形式）。 
36. IL_0068: leave.s IL_0079 
37. } // end .try 
38. finally 
39. { 
40. //将位于特定索引处的局部变量的地址加载到计算堆栈上（短格式）。 
41. IL_006a: ldloca.s CS$5$0001 
42. //约束要对其进行虚方法调用的类型 
43. IL_006c: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32> 
44. //调用Dispose()将IEnumerator对象Dispose掉 
45. IL_0072: callvirt instance void [mscorlib]System.IDisposable::Dispose() 
46. IL_0077: nop 
47. //将控制从异常块的 fault 或 finally 子句转移回公共语言结构 (CLI) 异常处理程序 
48. IL_0078: endfinally 
49. } // end handler 

       从这里我们可以看出for方式的遍历是直接对元素集合本身的遍历，而foreach方式的遍历是对获取到元素集合的实现IEnumerator接口的对象，通过这个Current属性，调用MoveNext()函数对集合进行遍历的。

       下面我们来看看for和foreach对List对象的不同数据量级别的访问时间如下,首先我们看耗时测算代码如下：

时间耗时测算代码

 

1. class Program 
2. { 
3. static void Main(string[] args) 
4. { 
5. //初始化一个List<int> 
6. List<int> listInt = new List<int>(); 
7. for (int i = 0; i < 1000000; i++) 
8. { 
9. listInt.Add(i + 1); 
10. } 
11. Console.WriteLine("--------------------------"); 
12. //第一种for遍历 
13. Stopwatch sw1 = new Stopwatch(); 
14. sw1.Start(); 
15. for (int i = 0; i < listInt.Count; i++) 
16. { 
17. } 
18. sw1.Stop(); 
19. Stopwatch sw2 = new Stopwatch(); 
20. sw2.Start(); 
21. //第二种foreach遍历 
22. foreach (int i in listInt) 
23. { 
24. } 
25. sw2.Stop(); 
26. Console.WriteLine("当前得List<int>对象数目："+listInt.Count.ToString()); 
27. Console.WriteLine(@"for 的遍历消耗时间是:" + sw1.Elapsed); 
28. Console.WriteLine(@"foreach 的遍历消耗时间是:" + sw2.Elapsed); 
29. Console.ReadLine(); 
30. } 
31. } 

       首先List<int> listInt为100的耗时如下三图：

       其次List<int> listInt为10000的耗时如下三图：

       最后我们看看List<int> listInt为10000的耗时如下三图：

       结语：通过本篇文章的CIL我们知道了for和foreach在.NET环境的中间语言中是如何控制和循环的，另外也更加深入的了解for和foreach的区别。最后对于效率的比较可能和环境等有比较大的差异，大家可以不放可以自己建立一个控制台程序试试。

转载于:https://blog.51cto.com/chengxingliang/826737