由浅入深CIL系列:4.抛砖引玉：使用CIL来分析string类型在.NET运算中的性能和避免装箱

          一、在.NET中string是一种特殊的引用类型，它一旦被赋值在堆上的地址即不可改变，之后对其进行的字符串相加等操作之后的结果都指向另外一个堆地址，而非原来的字符串地址。现在我们看以下一段C#代码以观察string在实际编码过程中的使用。

1. class Program 
2. { 
3. static void Main(string[] args) 
4. { 
5. //打印One Word 
6. string str1 = "One"; 
7. str1 += " Word"; 
8. Console.WriteLine(str1); 
9.  
10. string str2 = "One"+" Word"; 
11. Console.WriteLine(str2); 
12.  
13. //打印One Word43 
14. int i = 43; 
15. Console.WriteLine(str1+i); 
16.  
17. Console.WriteLine(str1 + i.ToString()); 
18. } 
19. } 

        二、上面的C#生成的CIL代码如下：

1. .method private hidebysig static void Main(string[] args) cil managed 
2. { 
3. //初始化 
4. .entrypoint 
5. // 代码大小 80 (0x50) 
6. .maxstack 2 
7. .locals init ([0] string str1, 
8. [1] string str2, 
9. [2] int32 i) 
10.  
11. //两个字符串分为两个步骤相加 
12. IL_0000: nop 
13. IL_0001: ldstr "One" 
14. IL_0006: stloc.0 
15. IL_0007: ldloc.0 
16. IL_0008: ldstr " Word" 
17. IL_000d: call string [mscorlib]System.String::Concat(string, 
18. string) 
19. IL_0012: stloc.0 
20. IL_0013: ldloc.0 
21. IL_0014: call void [mscorlib]System.Console::WriteLine(string) 
22.  
23. //两个字符串在同一行里面进行相加 被翻译为CIL时就已经连接到一起 
24. IL_0019: nop 
25. IL_001a: ldstr "One Word" 
26. IL_001f: stloc.1 
27. IL_0020: ldloc.1 
28. IL_0021: call void [mscorlib]System.Console::WriteLine(string) 
29.  
30. //将Int32字符装箱再和String合并打印 
31. IL_0026: nop 
32. IL_0027: ldc.i4.s 43 
33. IL_0029: stloc.2 
34. IL_002a: ldloc.0 
35. IL_002b: ldloc.2 
36. IL_002c: box [mscorlib]System.Int32 
37. IL_0031: call string [mscorlib]System.String::Concat(object, 
38. object) 
39. IL_0036: call void [mscorlib]System.Console::WriteLine(string) 
40.  
41. //直接调用数字的ToString()方法 
42. IL_003b: nop 
43. IL_003c: ldloc.0 
44. IL_003d: ldloca.s i 
45. IL_003f: call instance string [mscorlib]System.Int32::ToString() 
46. IL_0044: call string [mscorlib]System.String::Concat(string, 
47. string) 
48. IL_0049: call void [mscorlib]System.Console::WriteLine(string) 
49. IL_004e: nop 
50. IL_004f: ret 
51. } // end of method Program::Main 

        三、首先我们看两种字符串的构造方式的不同而引起的效能变化。

              第1种

1. //打印One Word 
2. string str1 = "One"; 
3. str1 += " Word"; 
4. Console.WriteLine(str1); 

1. //第一种、两个字符串分为两个步骤相加 
2. IL_0000: nop 
3. IL_0001: ldstr "One" //将One字符串存到堆上并且将其引用压栈 
4. IL_0006: stloc.0 //从栈顶部的One字符串引用地址弹出到第一个参数0 
5. IL_0007: ldloc.0 //将索引 0 处的局部变量加载到计算堆栈上 
6. IL_0008: ldstr " Word" //将Word字符串存到堆上并且将其引用返回到计算机栈上 
7. //调用系统函数将上面两个字符串相加其结果存到栈顶 
8. IL_000d: call string [mscorlib]System.String::Concat(string, 
9. string) 
10. IL_0012: stloc.0 //从栈顶部的One字符串引用地址弹出到第一个参数0 
11. IL_0013: ldloc.0 //将索引 0 处的局部变量加载到计算堆栈上 
12. //调用系统参数打印One Word 
13. IL_0014: call void [mscorlib]System.Console::WriteLine(string) 

             第2种

1. string str2 = "One"+" Word"; 
2. Console.WriteLine(str2); 

1. //两个字符串在同一行里面进行相加 被翻译为CIL时就已经连接到一起 
2. IL_0019: nop 
3. IL_001a: ldstr "One Word" //直接已经构造成One Word 
4. IL_001f: stloc.1 //从栈顶部的One Word字符串引用地址弹出到第一个参数1 
5. IL_0020: ldloc.1 //将索引 1 处的局部变量加载到计算堆栈上 
6. //调用系统参数打印One Word 
7. IL_0021: call void [mscorlib]System.Console::WriteLine(string) 

        结论：通过上面两种方式构造方式的CIL我们可以很清晰的看出第二种方式的效率要高于第一种的字符串构造方式。所以我们在实际的编码过程中可以考虑尽量使用第二种编码方式。

        四、大家都知道装箱操作会在堆上寻找一个控件来存储值类型的值。会耗费大量的时间。所以下面我们来看两个实例代码

               第1种

1. int i = 43; 
2. Console.WriteLine(str1+i); 
3.  
4. //将Int32字符装箱再和String合并打印 
5. IL_0026: nop 
6. IL_0027: ldc.i4.s 43 
7. IL_0029: stloc.2 
8. IL_002a: ldloc.0 
9. IL_002b: ldloc.2 
10. IL_002c: box [mscorlib]System.Int32 //在这里有一个装箱的操作 
11. IL_0031: call string [mscorlib]System.String::Concat(object, 
12. object) 
13. IL_0036: call void [mscorlib]System.Console::WriteLine(string) 

                 第2种

1. int i = 43;  
2. Console.WriteLine(str1 + i.ToString());  
3.  
4. //直接调用数字的ToString()方法  
5. IL_003b: nop  
6. IL_003c: ldloc.0  
7. IL_003d: ldloca.s i  
8. //这里没有装箱的操作，仅仅调用了重载的ToString()方法  
9. IL_003f: call instance string [mscorlib]System.Int32::ToString()  
10. IL_0044: call string [mscorlib]System.String::Concat(string,  
11. string)  
12. IL_0049: call void [mscorlib]System.Console::WriteLine(string)  
13. IL_004e: nop  

        结论：在这里我们分析第一种情况是对Int32值进行了box装箱操作，然后调用系统函数和第一个 string相加才得到结果的。而第二种情况是直接对Int32调用其重载函数ToString()得到Int32值的字符再与第一个字符相加。在这里我 们避免了装箱分配堆地址查找空余堆地址等麻烦，所以如果再一个循环语句中，第二种情况肯定效率要高很多。

本文转自程兴亮 51CTO博客，原文链接:http://blog.51cto.com/chengxingliang/826595