由浅入深CIL系列:5.抛砖引玉：判断string是否为空的四种方法的CIL代码看看效率如何？

本节将接触几个新的CIL操作码如下

              ldc.i4.0    将整数值 0 作为 int32 推送到计算堆栈上

              Ceq         比较两个值。如果这两个值相等，则将整数值 1 (int32) 推送到计算堆栈上；否则，将 0 (int32) 推送到计算堆栈上。

              Brtrue.s   如果 value 为 true、非空或非零，则将控制转移到目标指令（短格式）。

              Brfalse.S  如果 value 为 false、空引用或零，则将控制转移到目标指令。

              Callvirt     对对象调用后期绑定方法，并且将返回值推送到计算堆栈上。

              Ldsfld      将静态字段的值推送到计算堆栈上。

源代码

        一、在.NET有几种判断string是否为空的方法，也有两种判断值是否相等的方法。下面我们来看看：

1. class Program 
2. { 
3. static void Main(string[] args) 
4. { 
5. //判断字符串是否为空 
6. string str1 = "MyWord"; 
7. if (str1 == "") 
8. ; 
9. if (str1 == string.Empty) 
10. ; 
11.             if (str1 != null && str1.Length== 0) 
12.                 ; 
13.             if (string.IsNullOrEmpty(str1)) 
14.                 ; 
15.    } 
16. } 

        二、下面我们看看上面的Cs代码生成的CIL代码如下：

1. .method private hidebysig static void Main(string[] args) cil managed 
2. { 
3. .entrypoint 
4. // 代码大小 85 (0x55) 
5. .maxstack 2 
6. //声明3个参数，分别是str1和bool值 
7. .locals init ([0] string str1, 
8. [1] bool CS$4$0000) 
9. IL_0000: nop 
10. //推送对元数据中存储的"MyWord"字符串的新对象引用 
11. IL_0001: ldstr "MyWord" 
12. //将"MyWord"压栈到参数0 
13. IL_0006: stloc.0 
14.   
15.  
16.   
17.  
18.  
19.  //--------string空判断第一种方法  if (str1 == "")  -------- 
20. //将"MyWord"从参数0处加载到计算堆栈上  
21.   IL_0007:  ldloc.0 
22. //推送对元数据中存储的""字符串的新对象引用 
23.   IL_0008:  ldstr      "" 
24. //通过System.String::op_Equality函数判断是否相等 
25.   IL_000d:  call       bool [mscorlib]System.String::op_Equality(string, 
26.                                                                  string) 
27. //将整数值 0 作为 int32 推送到计算堆栈上 
28.   IL_0012:  ldc.i4.0 
29. //ceq比较两个值。如果这两个值相等，则将整数值 1 (int32)推送到计算堆栈上； 
30. //否则，将 0 (int32) 推送到计算堆栈上。  
31.   IL_0013:  ceq 
32. //将true或者false的bool值弹出栈存到参数1去 
33.   IL_0015:  stloc.1 
34. //从参数1中加载数据到计算堆栈上去   
35.   IL_0016:  ldloc.1 
36. //如果 value 为 true、非空或非零，则将控制转移到目标指令（短格式）。 
37. //也就是if判断中如果结果为true的话，则运行内部代码  
38.   IL_0017:  brtrue.s   IL_0019 
39.  
40.  
41.  
42.  //--------string空判断第二种方法  if (str1 == string.Empty)  -------- 
43.   IL_0019:  ldloc.0 
44. //Ldsfld 将静态字段的值推送到计算堆栈上。 
45.   IL_001a:  ldsfld     string [mscorlib]System.String::Empty 
46.   IL_001f:  call       bool [mscorlib]System.String::op_Equality(string, 
47.                                                                  string) 
48.   IL_0024:  ldc.i4.0 
49.   IL_0025:  ceq 
50.   IL_0027:  stloc.1 
51.   IL_0028:  ldloc.1 
52.   IL_0029:  brtrue.s   IL_002b 
53.  
54.  
55.  
56.  
57.  //--------string空判断第三种方法  if (str1!=null&&str1.Length == 0)  --------   
58.   IL_002b:  ldloc.0 
59. //对象调用后期绑定方法，并且将返回值推送到计算堆栈上。<==> str1!=null 
60.   IL_002c:  brfalse.s  IL_003c 
61.   IL_002e:  ldloc.0 
62. //调用系统函数获取长度 
63.   IL_002f:  callvirt   instance int32 [mscorlib]System.String::get_Length() 
64.   IL_0034:  ldc.i4.0 
65.   IL_0035:  ceq 
66.   IL_0037:  ldc.i4.0 
67.   IL_0038:  ceq 
68.   IL_003a:  br.s       IL_003d 
69.   IL_003c:  ldc.i4.1 
70.   IL_003d:  stloc.1 
71.   IL_003e:  ldloc.1 
72.   IL_003f:  brtrue.s   IL_0041 
73.  
74.  
75.  
76. //--------string空判断第四种方法  if (string.IsNullOrEmpty(str1))  --------   
77.   IL_0041:  ldloc.0 
78. //直接调用系统System.String::IsNullOrEmpty(string)函数比对 
79.   IL_0042:  call       bool [mscorlib]System.String::IsNullOrEmpty(string) 
80.   IL_0047:  ldc.i4.0 
81.   IL_0048:  ceq 
82.   IL_004a:  stloc.1 
83.   IL_004b:  ldloc.1 
84.   IL_004c:  brtrue.s   IL_004e 
85. } // end of method Program::Main 

 4种方法的CIL分析

              A.if (str1 == "")，在这里我们需要新构造一个""空字符，然后再调用System.String::op_Equality(string,string)函数对str1和空字符进行对比。

1. //--------string空判断第一种方法 if (str1 == "") -------- 
2. //将"MyWord"从参数0处加载到计算堆栈上 
3. IL_0007: ldloc.0 
4. //推送对元数据中存储的""字符串的新对象引用 
5. IL_0008: ldstr "" 
6. //通过System.String::op_Equality函数判断是否相等 
7. IL_000d: call bool [mscorlib]System.String::op_Equality(string, 
8. string) 
9. //将整数值 0 作为 int32 推送到计算堆栈上 
10. IL_0012: ldc.i4.0 
11. //ceq比较两个值。如果这两个值相等，则将整数值 1 (int32)推送到计算堆栈上； 
12. //否则，将 0 (int32) 推送到计算堆栈上。 
13. IL_0013: ceq 
14. //将true或者false的bool值弹出栈存到参数1去 
15. IL_0015: stloc.1 
16. //从参数1中加载数据到计算堆栈上去 
17. IL_0016: ldloc.1 
18. //如果 value 为 true、非空或非零，则将控制转移到目标指令（短格式）。 
19. //也就是if判断中如果结果为true的话，则运行内部代码 
20. IL_0017: brtrue.s IL_0019 

              B.if (str1 == string.Empty)，在这里我们通过string [mscorlib]System.String::Empty加载一个CIL代码为.field public static initonly string Empty的静态字段，然后让str1和这个静态字段做比较System.String::op_Equality(string,string)，以确定是否为空。

1. //--------string空判断第二种方法 if (str1 == string.Empty) -------- 
2. IL_0019: ldloc.0 
3. //Ldsfld 将静态字段的值推送到计算堆栈上。 
4. IL_001a: ldsfld string [mscorlib]System.String::Empty 
5. IL_001f: call bool [mscorlib]System.String::op_Equality(string, 
6. string) 
7. IL_0024: ldc.i4.0 
8. IL_0025: ceq 
9. IL_0027: stloc.1 
10. IL_0028: ldloc.1 
11. IL_0029: brtrue.s IL_002b 

               C.if (str1.Length == 0)，在这里我们调用[mscorlib]System.String::get_Length()函数获取到字符串长度，然后这个长度和0相对比

1. //--------string空判断第三种方法 if (str1!=null&&str1.Length == 0) -------- 
2. IL_002b: ldloc.0 
3. //对象调用后期绑定方法，并且将返回值推送到计算堆栈上。<==> str1!=null 
4. IL_002c: brfalse.s IL_003c 
5. IL_002e: ldloc.0 
6. //调用系统函数获取长度 
7. IL_002f: callvirt instance int32 [mscorlib]System.String::get_Length() 
8. IL_0034: ldc.i4.0 
9. IL_0035: ceq 
10. IL_0037: ldc.i4.0 
11. IL_0038: ceq 
12. IL_003a: br.s IL_003d 
13. IL_003c: ldc.i4.1 
14. IL_003d: stloc.1 
15. IL_003e: ldloc.1 
16. IL_003f: brtrue.s IL_0041 

               D.if (string.IsNullOrEmpty(str1)),这种方式直接调用系统的System.String::IsNullOrEmpty(string)函数直接比对出结果。

1. //--------string空判断第四种方法 if (string.IsNullOrEmpty(str1)) -------- 
2. IL_0041: ldloc.0 
3. //直接调用系统System.String::IsNullOrEmpty(string)函数比对 
4. IL_0042: call bool [mscorlib]System.String::IsNullOrEmpty(string) 
5. IL_0047: ldc.i4.0 
6. IL_0048: ceq 
7. IL_004a: stloc.1 
8. IL_004b: ldloc.1 
9. IL_004c: brtrue.s IL_004e 

性能分析

        下面我们通过using System.Diagnostics;命名空间下的Stopwatch对象来计算这4种调用方式所消耗的大概时间。

请看cs代码如下：

1. class Program 
2. { 
3. static void Main(string[] args) 
4. { 
5. //判断字符串是否为空 
6. string str1 = "MyWord"; 
7. //第一种方法耗时计算 
8. Stopwatch sw1 = new Stopwatch(); 
9. sw1.Start(); 
10. if (str1 == "") 
11. ; 
12. sw1.Stop(); 
13. //第二种方法耗时计算 
14. Stopwatch sw2 = new Stopwatch(); 
15. sw2.Start(); 
16. if (str1 == string.Empty) 
17. ; 
18. sw2.Stop(); 
19. //第三种方法耗时计算 
20. Stopwatch sw3 = new Stopwatch(); 
21. sw3.Start(); 
22. if (str1!=null&&str1.Length == 0) 
23. ; 
24. sw3.Stop(); 
25. //第四种方法耗时计算 
26. Stopwatch sw4 = new Stopwatch(); 
27. sw4.Start(); 
28. if (string.IsNullOrEmpty(str1)) 
29. ; 
30. sw4.Stop(); 
31.  
32. Console.WriteLine(@"if (str1 == "")的判断时间是：" + sw1.Elapsed); 
33. Console.WriteLine(@"if (str1 == string.Empty)的判断时间是：" + sw2.Elapsed); 
34. Console.WriteLine(@"if (str1!=null&&str1.Length == 0)的判断时间是：" + sw3.Elapsed); 
35. Console.WriteLine(@"if (string.IsNullOrEmpty(str1)) 的判断时间是：" + sw4.Elapsed); 
36. Console.ReadLine(); 
37.  
38. } 

        然后我们需要看看结果如何，为了提高精确度，我们运行多次结果，然后就知道哪种方式的效率最高。

下面我们来看在我的电脑上的运行时间情况如下面的图所示：

       然后我将这段代码发我一个朋友那里得到的运行情况如下图所示：

        鉴于时间跨度太小，以及各种运行环境的不同，还有其他一些原因，对于结果和答案都有有所影响，所以上面的运行结果仅做参考。大家也可以将这段测试代码在自己的电脑上运行一下，看看究竟结果如何？

思考：这4种方法的效率究竟谁高谁低？应该如何排序？为什么形成这样的差异？

扩展阅读：

       I.1第一种方法和第二种方法都会使用到一个System.String::op_Equality(string,string)方法，这个方法的CIL代码我们使用ILDASM查看mscorlib.dll文件即可：

        I.2上面这段IL代码内部调用了bool System.String::Equals(string,string)方法，这个方法的CIL代码如下：

1. .method public hidebysig static bool Equals(string a, 
2. string b) cil managed 
3. { 
4. // 代码大小 22 (0x16) 
5. .maxstack 8 
6. IL_0000: ldarg.0 
7. IL_0001: ldarg.1 
8. IL_0002: bne.un.s IL_0006 
9. IL_0004: ldc.i4.1 
10. IL_0005: ret 
11. IL_0006: ldarg.0 
12. IL_0007: brfalse.s IL_000c 
13. IL_0009: ldarg.1 
14. IL_000a: brtrue.s IL_000e 
15. IL_000c: ldc.i4.0 
16. IL_000d: ret 
17. IL_000e: ldarg.0 
18. IL_000f: ldarg.1 
19. IL_0010: call bool System.String::EqualsHelper(string, 
20. string) 
21. IL_0015: ret 
22. } // end of method String::Equals 

       I.3上面这段IL代码内部调用了bool System.String::EqualsHelper(string, string) 方法，这个方法的CIL代码如下，其内部调用了多次int32 System.String::get_Length()函数：  

1. .method private hidebysig static bool EqualsHelper(string strA, 
2. string strB) cil managed 
3. { 
4. .custom instance void System.Security.SecuritySafeCriticalAttribute::.ctor() = ( 01 00 00 00 ) 
5. .custom instance void System.Runtime.ConstrainedExecution.ReliabilityContractAttribute::.ctor(valuetype System.Runtime.ConstrainedExecution.Consistency, 
6. valuetype System.Runtime.ConstrainedExecution.Cer) = ( 01 00 03 00 00 00 01 00 00 00 00 00 ) 
7. // 代码大小 199 (0xc7) 
8. .maxstack 3 
9. .locals init (int32 V_0, 
10. char& pinned V_1, 
11. char& pinned V_2, 
12. char* V_3, 
13. char* V_4, 
14. bool V_5) 
15. IL_0000: ldarg.0 
16. IL_0001: callvirt instance int32 System.String::get_Length() 
17. IL_0006: stloc.0 
18. IL_0007: ldloc.0 
19. IL_0008: ldarg.1 
20. IL_0009: callvirt instance int32 System.String::get_Length() 
21. IL_000e: beq.s IL_0012 
22. IL_0010: ldc.i4.0 
23. IL_0011: ret 
24. IL_0012: ldarg.0 
25. IL_0013: ldflda char System.String::m_firstChar 
26. IL_0018: stloc.1 
27. IL_0019: ldarg.1 
28. IL_001a: ldflda char System.String::m_firstChar 
29. IL_001f: stloc.2 
30. IL_0020: ldloc.1 
31. IL_0021: conv.i 
32. IL_0022: stloc.3 
33. IL_0023: ldloc.2 
34. IL_0024: conv.i 
35. IL_0025: stloc.s V_4 
36. IL_0027: br.s IL_0097 
37. IL_0029: ldloc.3 
38. IL_002a: ldind.i4 
39. IL_002b: ldloc.s V_4 
40. IL_002d: ldind.i4 
41. IL_002e: beq.s IL_0038 
42. IL_0030: ldc.i4.0 
43. IL_0031: stloc.s V_5 
44. IL_0033: leave IL_00c4 
45. IL_0038: ldloc.3 
46. IL_0039: ldc.i4.4 
47. IL_003a: conv.i 
48. IL_003b: add 
49. IL_003c: ldind.i4 
50. IL_003d: ldloc.s V_4 
51. IL_003f: ldc.i4.4 
52. IL_0040: conv.i 
53. IL_0041: add 
54. IL_0042: ldind.i4 
55. IL_0043: beq.s IL_004a 
56. IL_0045: ldc.i4.0 
57. IL_0046: stloc.s V_5 
58. IL_0048: leave.s IL_00c4 
59. IL_004a: ldloc.3 
60. IL_004b: ldc.i4.8 
61. IL_004c: conv.i 
62. IL_004d: add 
63. IL_004e: ldind.i4 
64. IL_004f: ldloc.s V_4 
65. IL_0051: ldc.i4.8 
66. IL_0052: conv.i 
67. IL_0053: add 
68. IL_0054: ldind.i4 
69. IL_0055: beq.s IL_005c 
70. IL_0057: ldc.i4.0 
71. IL_0058: stloc.s V_5 
72. IL_005a: leave.s IL_00c4 
73. IL_005c: ldloc.3 
74. IL_005d: ldc.i4.s 12 
75. IL_005f: conv.i 
76. IL_0060: add 
77. IL_0061: ldind.i4 
78. IL_0062: ldloc.s V_4 
79. IL_0064: ldc.i4.s 12 
80. IL_0066: conv.i 
81. IL_0067: add 
82. IL_0068: ldind.i4 
83. IL_0069: beq.s IL_0070 
84. IL_006b: ldc.i4.0 
85. IL_006c: stloc.s V_5 
86. IL_006e: leave.s IL_00c4 
87. IL_0070: ldloc.3 
88. IL_0071: ldc.i4.s 16 
89. IL_0073: conv.i 
90. IL_0074: add 
91. IL_0075: ldind.i4 
92. IL_0076: ldloc.s V_4 
93. IL_0078: ldc.i4.s 16 
94. IL_007a: conv.i 
95. IL_007b: add 
96. IL_007c: ldind.i4 
97. IL_007d: beq.s IL_0084 
98. IL_007f: ldc.i4.0 
99. IL_0080: stloc.s V_5 
100. IL_0082: leave.s IL_00c4 
101. IL_0084: ldloc.3 
102. IL_0085: ldc.i4.s 20 
103. IL_0087: conv.i 
104. IL_0088: add 
105. IL_0089: stloc.3 
106. IL_008a: ldloc.s V_4 
107. IL_008c: ldc.i4.s 20 
108. IL_008e: conv.i 
109. IL_008f: add 
110. IL_0090: stloc.s V_4 
111. IL_0092: ldloc.0 
112. IL_0093: ldc.i4.s 10 
113. IL_0095: sub 
114. IL_0096: stloc.0 
115. IL_0097: ldloc.0 
116. IL_0098: ldc.i4.s 10 
117. IL_009a: bge.s IL_0029 
118. IL_009c: br.s IL_00b5 
119. IL_009e: ldloc.3 
120. IL_009f: ldind.i4 
121. IL_00a0: ldloc.s V_4 
122. IL_00a2: ldind.i4 
123. IL_00a3: bne.un.s IL_00b9 
124. IL_00a5: ldloc.3 
125. IL_00a6: ldc.i4.4 
126. IL_00a7: conv.i 
127. IL_00a8: add 
128. IL_00a9: stloc.3 
129. IL_00aa: ldloc.s V_4 
130. IL_00ac: ldc.i4.4 
131. IL_00ad: conv.i 
132. IL_00ae: add 
133. IL_00af: stloc.s V_4 
134. IL_00b1: ldloc.0 
135. IL_00b2: ldc.i4.2 
136. IL_00b3: sub 
137. IL_00b4: stloc.0 
138. IL_00b5: ldloc.0 
139. IL_00b6: ldc.i4.0 
140. IL_00b7: bgt.s IL_009e 
141. IL_00b9: ldloc.0 
142. IL_00ba: ldc.i4.0 
143. IL_00bb: cgt 
144. IL_00bd: ldc.i4.0 
145. IL_00be: ceq 
146. IL_00c0: stloc.s V_5 
147. IL_00c2: leave.s IL_00c4 
148. IL_00c4: ldloc.s V_5 
149. IL_00c6: ret 
150. } // end of method String::EqualsHelper 

        II.1在第三种方法的CIL代码中我们调用了一次int32 [mscorlib]System.String::get_Length()函数.

        III.1在第四种方法的CIL代码中调用了一次bool [mscorlib]System.String::IsNullOrEmpty(string)函数，此函数的CIL代码如下,它内部调用了一次System.String::get_Length()函数：

1. .method public hidebysig static bool IsNullOrEmpty(string 'value') cil managed 
2. { 
3. // 代码大小 15 (0xf) 
4. .maxstack 8 
5. IL_0000: ldarg.0 
6. IL_0001: brfalse.s IL_000d 
7. IL_0003: ldarg.0 
8. IL_0004: callvirt instance int32 System.String::get_Length() 
9. IL_0009: ldc.i4.0 
10. IL_000a: ceq 
11. IL_000c: ret 
12. IL_000d: ldc.i4.1 
13. IL_000e: ret 
14. } // end of method String::IsNullOrEmpty