今天看到一篇文章，是关于在.NET中如何提升程序性能的，里面有这样一条：

建议使用+=、-= 等简化操作符
例如原有表达式 A=A+B
改为A+=B
这样不仅减少了敲入代码的数量，而且由于变量A只出现一次，在运行时也提高了系统的性能。

确实这样的操作能减少输入，但是对于是否真能提高性能，以及以什么方式来提高性能（是优化了代码还是节省了空间等），确实不太知道，带着好奇心，自己动手试试了。首先写了两个测试方法：

1. static void test1()     
2.  
3.      {     
4.          string A = "string A";     
5.          string B = "string B";     
6.          A += B;     
7.      }     
8.    
9.      static void test2()     
10.      {     
11.          string A = "string A";     
12.          string B = "string B";     
13.          A = A + B;     
14.      }  

编译后用ildasm查看两者的IL，可以看出，两个方法的IL是一致的：

1. .maxstack  2     
2. .locals init ([0] string A,     
3.          [1] string B)     
4. IL_0000:  nop     
5. IL_0001:  ldstr      "string A"    
6. IL_0006:  stloc.0     
7. IL_0007:  ldstr      "string B"    
8. IL_000c:  stloc.1     
9. IL_000d:  ldloc.0     
10. IL_000e:  ldloc.1     
11. IL_000f:  call       string [mscorlib]System.String::Concat(string,     
12.                                                             string)     
13. IL_0014:  stloc.0     
14. IL_0015:  ret  

既然IL都是完全一样的，想必用reflector反编译后的代码也是一样的喽。

这里分别按优化级别来查看：

1. //优化级别为NONE  
2.  
3. private static void test1()//或者test2  
4. {  
5.     string A;  
6.     string B;  
7.     A = "string A";  
8.     B = "string B";  
9.     A = A + B;  
10.     return;  
11. }//优化级别为.NET 3.5private static void test1()()//或者test2   
12. {  
13.     string A = "string A";  
14.     string B = "string B";  
15.     A = A + B;  
16. } 

（这里看出的代码不同是CLR平台对于我所写的代码的优化，而不是关于我们讨论的+=是否优化，别混淆）
由此看来，无论从哪个角度来看，所谓的提高性能是子虚乌有的，仅仅是.NET提供的一个语法糖，简化操作，并无特别的处理。

确实有点小题大做，但至少可以说明在学习过程中，不仅需要多看文章，同时也要能独立的思考，能够动手去验证一个别人的观点也是一种好的习惯。就比如现在有许多关于“优化”方面的建议，当然大部分都是正确的（肯定不是靠感觉出来的，尤其是对于优化方面，经常需要被量化出来才能确定的），然而也是需要条件的，就比如对于string和stringbuilder的讨论，似乎没有人说过以后不要用string之类的话吧；还有一部分，需要在以后的学习实践中，等到有能力的时候，去试试验证一下。