且构网

分享程序员开发的那些事...
且构网 - 分享程序员编程开发的那些事
您所在的位置：首页 > 由浅入深CIL系列:5.抛砖引玉：判断string是否为空的四种方法的CIL代码看看效率如何？

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

更新时间：2022-10-04 16:27:59

本节将接触几个新的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. 

  2. { 
    3. 

  3. static void Main(string[] args) 
    4. 

  4. { 
    5. 

  5. //判断字符串是否为空 
    6. 

  6. string str1 = "MyWord"; 
    7. 

  7. if (str1 == "") 
    8. 

  8. ; 
    9. 

  9. if (str1 == string.Empty) 
    10. 

  10. ; 
    11. 

  11.             if (str1 != null && str1.Length== 0) 
    12. 

  12.                 ; 
    13. 

  13.             if (string.IsNullOrEmpty(str1)) 
    14. 

  14.                 ; 
    15. 

  15.    } 
    16. 

  16. } 
    17. 



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




    

  1. .method private hidebysig static void Main(string[] args) cil managed 
    2. 

  2. { 
    3. 

  3. .entrypoint 
    4. 

  4. // 代码大小 85 (0x55) 
    5. 

  5. .maxstack 2 
    6. 

  6. //声明3个参数，分别是str1和bool值 
    7. 

  7. .locals init ([0] string str1, 
    8. 

  8. [1] bool CS$4$0000) 
    9. 

  9. IL_0000: nop 
    10. 

  10. //推送对元数据中存储的"MyWord"字符串的新对象引用 
    11. 

  11. IL_0001: ldstr "MyWord" 
    12. 

  12. //将"MyWord"压栈到参数0 
    13. 

  13. IL_0006: stloc.0 
    14. 

  14.   
    15. 

  15.  
    16. 

  16.   
    17. 

  17.  
    18. 

  18.  
    19. 

  19.  //--------string空判断第一种方法  if (str1 == "")  -------- 
    20. 

  20. //将"MyWord"从参数0处加载到计算堆栈上  
    21. 

  21.   IL_0007:  ldloc.0 
    22. 

  22. //推送对元数据中存储的""字符串的新对象引用 
    23. 

  23.   IL_0008:  ldstr      "" 
    24. 

  24. //通过System.String::op_Equality函数判断是否相等 
    25. 

  25.   IL_000d:  call       bool [mscorlib]System.String::op_Equality(string, 
    26. 

  26.                                                                  string) 
    27. 

  27. //将整数值 0 作为 int32 推送到计算堆栈上 
    28. 

  28.   IL_0012:  ldc.i4.0 
    29. 

  29. //ceq比较两个值。如果这两个值相等，则将整数值 1 (int32)推送到计算堆栈上； 
    30. 

  30. //否则，将 0 (int32) 推送到计算堆栈上。  
    31. 

  31.   IL_0013:  ceq 
    32. 

  32. //将true或者false的bool值弹出栈存到参数1去 
    33. 

  33.   IL_0015:  stloc.1 
    34. 

  34. //从参数1中加载数据到计算堆栈上去   
    35. 

  35.   IL_0016:  ldloc.1 
    36. 

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

  37. //也就是if判断中如果结果为true的话，则运行内部代码  
    38. 

  38.   IL_0017:  brtrue.s   IL_0019 
    39. 

  39.  
    40. 

  40.  
    41. 

  41.  
    42. 

  42.  //--------string空判断第二种方法  if (str1 == string.Empty)  -------- 
    43. 

  43.   IL_0019:  ldloc.0 
    44. 

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

  45.   IL_001a:  ldsfld     string [mscorlib]System.String::Empty 
    46. 

  46.   IL_001f:  call       bool [mscorlib]System.String::op_Equality(string, 
    47. 

  47.                                                                  string) 
    48. 

  48.   IL_0024:  ldc.i4.0 
    49. 

  49.   IL_0025:  ceq 
    50. 

  50.   IL_0027:  stloc.1 
    51. 

  51.   IL_0028:  ldloc.1 
    52. 

  52.   IL_0029:  brtrue.s   IL_002b 
    53. 

  53.  
    54. 

  54.  
    55. 

  55.  
    56. 

  56.  
    57. 

  57.  //--------string空判断第三种方法  if (str1!=null&&str1.Length == 0)  --------   
    58. 

  58.   IL_002b:  ldloc.0 
    59. 

  59. //对象调用后期绑定方法，并且将返回值推送到计算堆栈上。<==> str1!=null 
    60. 

  60.   IL_002c:  brfalse.s  IL_003c 
    61. 

  61.   IL_002e:  ldloc.0 
    62. 

  62. //调用系统函数获取长度 
    63. 

  63.   IL_002f:  callvirt   instance int32 [mscorlib]System.String::get_Length() 
    64. 

  64.   IL_0034:  ldc.i4.0 
    65. 

  65.   IL_0035:  ceq 
    66. 

  66.   IL_0037:  ldc.i4.0 
    67. 

  67.   IL_0038:  ceq 
    68. 

  68.   IL_003a:  br.s       IL_003d 
    69. 

  69.   IL_003c:  ldc.i4.1 
    70. 

  70.   IL_003d:  stloc.1 
    71. 

  71.   IL_003e:  ldloc.1 
    72. 

  72.   IL_003f:  brtrue.s   IL_0041 
    73. 

  73.  
    74. 

  74.  
    75. 

  75.  
    76. 

  76. //--------string空判断第四种方法  if (string.IsNullOrEmpty(str1))  --------   
    77. 

  77.   IL_0041:  ldloc.0 
    78. 

  78. //直接调用系统System.String::IsNullOrEmpty(string)函数比对 
    79. 

  79.   IL_0042:  call       bool [mscorlib]System.String::IsNullOrEmpty(string) 
    80. 

  80.   IL_0047:  ldc.i4.0 
    81. 

  81.   IL_0048:  ceq 
    82. 

  82.   IL_004a:  stloc.1 
    83. 

  83.   IL_004b:  ldloc.1 
    84. 

  84.   IL_004c:  brtrue.s   IL_004e 
    85. 

  85. } // end of method Program::Main 
    86. 



 4种方法的CIL分析


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




    

  1. //--------string空判断第一种方法 if (str1 == "") -------- 
    2. 

  2. //将"MyWord"从参数0处加载到计算堆栈上 
    3. 

  3. IL_0007: ldloc.0 
    4. 

  4. //推送对元数据中存储的""字符串的新对象引用 
    5. 

  5. IL_0008: ldstr "" 
    6. 

  6. //通过System.String::op_Equality函数判断是否相等 
    7. 

  7. IL_000d: call bool [mscorlib]System.String::op_Equality(string, 
    8. 

  8. string) 
    9. 

  9. //将整数值 0 作为 int32 推送到计算堆栈上 
    10. 

  10. IL_0012: ldc.i4.0 
    11. 

  11. //ceq比较两个值。如果这两个值相等，则将整数值 1 (int32)推送到计算堆栈上； 
    12. 

  12. //否则，将 0 (int32) 推送到计算堆栈上。 
    13. 

  13. IL_0013: ceq 
    14. 

  14. //将true或者false的bool值弹出栈存到参数1去 
    15. 

  15. IL_0015: stloc.1 
    16. 

  16. //从参数1中加载数据到计算堆栈上去 
    17. 

  17. IL_0016: ldloc.1 
    18. 

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

  19. //也就是if判断中如果结果为true的话，则运行内部代码 
    20. 

  20. IL_0017: brtrue.s IL_0019 
    21. 



              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. 

  2. IL_0019: ldloc.0 
    3. 

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

  4. IL_001a: ldsfld string [mscorlib]System.String::Empty 
    5. 

  5. IL_001f: call bool [mscorlib]System.String::op_Equality(string, 
    6. 

  6. string) 
    7. 

  7. IL_0024: ldc.i4.0 
    8. 

  8. IL_0025: ceq 
    9. 

  9. IL_0027: stloc.1 
    10. 

  10. IL_0028: ldloc.1 
    11. 

  11. IL_0029: brtrue.s IL_002b 
    12. 



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




    

  1. //--------string空判断第三种方法 if (str1!=null&&str1.Length == 0) -------- 
    2. 

  2. IL_002b: ldloc.0 
    3. 

  3. //对象调用后期绑定方法，并且将返回值推送到计算堆栈上。<==> str1!=null 
    4. 

  4. IL_002c: brfalse.s IL_003c 
    5. 

  5. IL_002e: ldloc.0 
    6. 

  6. //调用系统函数获取长度 
    7. 

  7. IL_002f: callvirt instance int32 [mscorlib]System.String::get_Length() 
    8. 

  8. IL_0034: ldc.i4.0 
    9. 

  9. IL_0035: ceq 
    10. 

  10. IL_0037: ldc.i4.0 
    11. 

  11. IL_0038: ceq 
    12. 

  12. IL_003a: br.s IL_003d 
    13. 

  13. IL_003c: ldc.i4.1 
    14. 

  14. IL_003d: stloc.1 
    15. 

  15. IL_003e: ldloc.1 
    16. 

  16. IL_003f: brtrue.s IL_0041 
    17. 



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


 




    

  1. //--------string空判断第四种方法 if (string.IsNullOrEmpty(str1)) -------- 
    2. 

  2. IL_0041: ldloc.0 
    3. 

  3. //直接调用系统System.String::IsNullOrEmpty(string)函数比对 
    4. 

  4. IL_0042: call bool [mscorlib]System.String::IsNullOrEmpty(string) 
    5. 

  5. IL_0047: ldc.i4.0 
    6. 

  6. IL_0048: ceq 
    7. 

  7. IL_004a: stloc.1 
    8. 

  8. IL_004b: ldloc.1 
    9. 

  9. IL_004c: brtrue.s IL_004e 
    10. 



性能分析


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


请看cs代码如下：


 




    

  1. class Program 
    2. 

  2. { 
    3. 

  3. static void Main(string[] args) 
    4. 

  4. { 
    5. 

  5. //判断字符串是否为空 
    6. 

  6. string str1 = "MyWord"; 
    7. 

  7. //第一种方法耗时计算 
    8. 

  8. Stopwatch sw1 = new Stopwatch(); 
    9. 

  9. sw1.Start(); 
    10. 

  10. if (str1 == "") 
    11. 

  11. ; 
    12. 

  12. sw1.Stop(); 
    13. 

  13. //第二种方法耗时计算 
    14. 

  14. Stopwatch sw2 = new Stopwatch(); 
    15. 

  15. sw2.Start(); 
    16. 

  16. if (str1 == string.Empty) 
    17. 

  17. ; 
    18. 

  18. sw2.Stop(); 
    19. 

  19. //第三种方法耗时计算 
    20. 

  20. Stopwatch sw3 = new Stopwatch(); 
    21. 

  21. sw3.Start(); 
    22. 

  22. if (str1!=null&&str1.Length == 0) 
    23. 

  23. ; 
    24. 

  24. sw3.Stop(); 
    25. 

  25. //第四种方法耗时计算 
    26. 

  26. Stopwatch sw4 = new Stopwatch(); 
    27. 

  27. sw4.Start(); 
    28. 

  28. if (string.IsNullOrEmpty(str1)) 
    29. 

  29. ; 
    30. 

  30. sw4.Stop(); 
    31. 

  31.  
    32. 

  32. Console.WriteLine(@"if (str1 == "")的判断时间是：" + sw1.Elapsed); 
    33. 

  33. Console.WriteLine(@"if (str1 == string.Empty)的判断时间是：" + sw2.Elapsed); 
    34. 

  34. Console.WriteLine(@"if (str1!=null&&str1.Length == 0)的判断时间是：" + sw3.Elapsed); 
    35. 

  35. Console.WriteLine(@"if (string.IsNullOrEmpty(str1)) 的判断时间是：" + sw4.Elapsed); 
    36. 

  36. Console.ReadLine(); 
    37. 

  37.  
    38. 

  38. } 
    39. 



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


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


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


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


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


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


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


扩展阅读：


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




System.String::op_Equality(string,string)





.method public hidebysig specialname static 
bool op_Equality(string a, 
string b) cil managed 
{ 
// 代码大小 8 (0x8) 
.maxstack 8 
IL_0000: ldarg.0 
IL_0001: ldarg.1 
IL_0002: call bool System.String::Equals(string, 
string) 
IL_0007: ret 
} // end of method String::op_Equality 

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


bool System.String::Equals(string,string)




    

  1. .method public hidebysig static bool Equals(string a, 
    2. 

  2. string b) cil managed 
    3. 

  3. { 
    4. 

  4. // 代码大小 22 (0x16) 
    5. 

  5. .maxstack 8 
    6. 

  6. IL_0000: ldarg.0 
    7. 

  7. IL_0001: ldarg.1 
    8. 

  8. IL_0002: bne.un.s IL_0006 
    9. 

  9. IL_0004: ldc.i4.1 
    10. 

  10. IL_0005: ret 
    11. 

  11. IL_0006: ldarg.0 
    12. 

  12. IL_0007: brfalse.s IL_000c 
    13. 

  13. IL_0009: ldarg.1 
    14. 

  14. IL_000a: brtrue.s IL_000e 
    15. 

  15. IL_000c: ldc.i4.0 
    16. 

  16. IL_000d: ret 
    17. 

  17. IL_000e: ldarg.0 
    18. 

  18. IL_000f: ldarg.1 
    19. 

  19. IL_0010: call bool System.String::EqualsHelper(string, 
    20. 

  20. string) 
    21. 

  21. IL_0015: ret 
    22. 

  22. } // end of method String::Equals 
    23. 




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



System.String::EqualsHelper(string,string)




    

  1. .method private hidebysig static bool EqualsHelper(string strA, 
    2. 

  2. string strB) cil managed 
    3. 

  3. { 
    4. 

  4. .custom instance void System.Security.SecuritySafeCriticalAttribute::.ctor() = ( 01 00 00 00 ) 
    5. 

  5. .custom instance void System.Runtime.ConstrainedExecution.ReliabilityContractAttribute::.ctor(valuetype System.Runtime.ConstrainedExecution.Consistency, 
    6. 

  6. valuetype System.Runtime.ConstrainedExecution.Cer) = ( 01 00 03 00 00 00 01 00 00 00 00 00 ) 
    7. 

  7. // 代码大小 199 (0xc7) 
    8. 

  8. .maxstack 3 
    9. 

  9. .locals init (int32 V_0, 
    10. 

  10. char& pinned V_1, 
    11. 

  11. char& pinned V_2, 
    12. 

  12. char* V_3, 
    13. 

  13. char* V_4, 
    14. 

  14. bool V_5) 
    15. 

  15. IL_0000: ldarg.0 
    16. 

  16. IL_0001: callvirt instance int32 System.String::get_Length() 
    17. 

  17. IL_0006: stloc.0 
    18. 

  18. IL_0007: ldloc.0 
    19. 

  19. IL_0008: ldarg.1 
    20. 

  20. IL_0009: callvirt instance int32 System.String::get_Length() 
    21. 

  21. IL_000e: beq.s IL_0012 
    22. 

  22. IL_0010: ldc.i4.0 
    23. 

  23. IL_0011: ret 
    24. 

  24. IL_0012: ldarg.0 
    25. 

  25. IL_0013: ldflda char System.String::m_firstChar 
    26. 

  26. IL_0018: stloc.1 
    27. 

  27. IL_0019: ldarg.1 
    28. 

  28. IL_001a: ldflda char System.String::m_firstChar 
    29. 

  29. IL_001f: stloc.2 
    30. 

  30. IL_0020: ldloc.1 
    31. 

  31. IL_0021: conv.i 
    32. 

  32. IL_0022: stloc.3 
    33. 

  33. IL_0023: ldloc.2 
    34. 

  34. IL_0024: conv.i 
    35. 

  35. IL_0025: stloc.s V_4 
    36. 

  36. IL_0027: br.s IL_0097 
    37. 

  37. IL_0029: ldloc.3 
    38. 

  38. IL_002a: ldind.i4 
    39. 

  39. IL_002b: ldloc.s V_4 
    40. 

  40. IL_002d: ldind.i4 
    41. 

  41. IL_002e: beq.s IL_0038 
    42. 

  42. IL_0030: ldc.i4.0 
    43. 

  43. IL_0031: stloc.s V_5 
    44. 

  44. IL_0033: leave IL_00c4 
    45. 

  45. IL_0038: ldloc.3 
    46. 

  46. IL_0039: ldc.i4.4 
    47. 

  47. IL_003a: conv.i 
    48. 

  48. IL_003b: add 
    49. 

  49. IL_003c: ldind.i4 
    50. 

  50. IL_003d: ldloc.s V_4 
    51. 

  51. IL_003f: ldc.i4.4 
    52. 

  52. IL_0040: conv.i 
    53. 

  53. IL_0041: add 
    54. 

  54. IL_0042: ldind.i4 
    55. 

  55. IL_0043: beq.s IL_004a 
    56. 

  56. IL_0045: ldc.i4.0 
    57. 

  57. IL_0046: stloc.s V_5 
    58. 

  58. IL_0048: leave.s IL_00c4 
    59. 

  59. IL_004a: ldloc.3 
    60. 

  60. IL_004b: ldc.i4.8 
    61. 

  61. IL_004c: conv.i 
    62. 

  62. IL_004d: add 
    63. 

  63. IL_004e: ldind.i4 
    64. 

  64. IL_004f: ldloc.s V_4 
    65. 

  65. IL_0051: ldc.i4.8 
    66. 

  66. IL_0052: conv.i 
    67. 

  67. IL_0053: add 
    68. 

  68. IL_0054: ldind.i4 
    69. 

  69. IL_0055: beq.s IL_005c 
    70. 

  70. IL_0057: ldc.i4.0 
    71. 

  71. IL_0058: stloc.s V_5 
    72. 

  72. IL_005a: leave.s IL_00c4 
    73. 

  73. IL_005c: ldloc.3 
    74. 

  74. IL_005d: ldc.i4.s 12 
    75. 

  75. IL_005f: conv.i 
    76. 

  76. IL_0060: add 
    77. 

  77. IL_0061: ldind.i4 
    78. 

  78. IL_0062: ldloc.s V_4 
    79. 

  79. IL_0064: ldc.i4.s 12 
    80. 

  80. IL_0066: conv.i 
    81. 

  81. IL_0067: add 
    82. 

  82. IL_0068: ldind.i4 
    83. 

  83. IL_0069: beq.s IL_0070 
    84. 

  84. IL_006b: ldc.i4.0 
    85. 

  85. IL_006c: stloc.s V_5 
    86. 

  86. IL_006e: leave.s IL_00c4 
    87. 

  87. IL_0070: ldloc.3 
    88. 

  88. IL_0071: ldc.i4.s 16 
    89. 

  89. IL_0073: conv.i 
    90. 

  90. IL_0074: add 
    91. 

  91. IL_0075: ldind.i4 
    92. 

  92. IL_0076: ldloc.s V_4 
    93. 

  93. IL_0078: ldc.i4.s 16 
    94. 

  94. IL_007a: conv.i 
    95. 

  95. IL_007b: add 
    96. 

  96. IL_007c: ldind.i4 
    97. 

  97. IL_007d: beq.s IL_0084 
    98. 

  98. IL_007f: ldc.i4.0 
    99. 

  99. IL_0080: stloc.s V_5 
    100. 

  100. IL_0082: leave.s IL_00c4 
    101. 

  101. IL_0084: ldloc.3 
    102. 

  102. IL_0085: ldc.i4.s 20 
    103. 

  103. IL_0087: conv.i 
    104. 

  104. IL_0088: add 
    105. 

  105. IL_0089: stloc.3 
    106. 

  106. IL_008a: ldloc.s V_4 
    107. 

  107. IL_008c: ldc.i4.s 20 
    108. 

  108. IL_008e: conv.i 
    109. 

  109. IL_008f: add 
    110. 

  110. IL_0090: stloc.s V_4 
    111. 

  111. IL_0092: ldloc.0 
    112. 

  112. IL_0093: ldc.i4.s 10 
    113. 

  113. IL_0095: sub 
    114. 

  114. IL_0096: stloc.0 
    115. 

  115. IL_0097: ldloc.0 
    116. 

  116. IL_0098: ldc.i4.s 10 
    117. 

  117. IL_009a: bge.s IL_0029 
    118. 

  118. IL_009c: br.s IL_00b5 
    119. 

  119. IL_009e: ldloc.3 
    120. 

  120. IL_009f: ldind.i4 
    121. 

  121. IL_00a0: ldloc.s V_4 
    122. 

  122. IL_00a2: ldind.i4 
    123. 

  123. IL_00a3: bne.un.s IL_00b9 
    124. 

  124. IL_00a5: ldloc.3 
    125. 

  125. IL_00a6: ldc.i4.4 
    126. 

  126. IL_00a7: conv.i 
    127. 

  127. IL_00a8: add 
    128. 

  128. IL_00a9: stloc.3 
    129. 

  129. IL_00aa: ldloc.s V_4 
    130. 

  130. IL_00ac: ldc.i4.4 
    131. 

  131. IL_00ad: conv.i 
    132. 

  132. IL_00ae: add 
    133. 

  133. IL_00af: stloc.s V_4 
    134. 

  134. IL_00b1: ldloc.0 
    135. 

  135. IL_00b2: ldc.i4.2 
    136. 

  136. IL_00b3: sub 
    137. 

  137. IL_00b4: stloc.0 
    138. 

  138. IL_00b5: ldloc.0 
    139. 

  139. IL_00b6: ldc.i4.0 
    140. 

  140. IL_00b7: bgt.s IL_009e 
    141. 

  141. IL_00b9: ldloc.0 
    142. 

  142. IL_00ba: ldc.i4.0 
    143. 

  143. IL_00bb: cgt 
    144. 

  144. IL_00bd: ldc.i4.0 
    145. 

  145. IL_00be: ceq 
    146. 

  146. IL_00c0: stloc.s V_5 
    147. 

  147. IL_00c2: leave.s IL_00c4 
    148. 

  148. IL_00c4: ldloc.s V_5 
    149. 

  149. IL_00c6: ret 
    150. 

  150. } // end of method String::EqualsHelper 
    151. 



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


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


System.String::IsNullOrEmpty(string）






    

  1. .method public hidebysig static bool IsNullOrEmpty(string 'value') cil managed 
    2. 

  2. { 
    3. 

  3. // 代码大小 15 (0xf) 
    4. 

  4. .maxstack 8 
    5. 

  5. IL_0000: ldarg.0 
    6. 

  6. IL_0001: brfalse.s IL_000d 
    7. 

  7. IL_0003: ldarg.0 
    8. 

  8. IL_0004: callvirt instance int32 System.String::get_Length() 
    9. 

  9. IL_0009: ldc.i4.0 
    10. 

  10. IL_000a: ceq 
    11. 

  11. IL_000c: ret 
    12. 

  12. IL_000d: ldc.i4.1 
    13. 

  13. IL_000e: ret 
    14. 

  14. } // end of method String::IsNullOrEmpty 
    15. 






本文转自程兴亮 51CTO博客，原文链接:

http://blog.51cto.com/chengxingliang/826603
上一篇 : ：Silverlight实用窍门系列：46.深入了解Silverlight的IValueConverter和TypeConverter下一篇 : Silverlight实用窍门系列：40.Silverlight中捕捉视频，截图保存到本地
相关阅读
推荐文章






网站首页网站地图Copyright © 2021-2022 且购网  
免责声明：本站文章部分来源于互联网,如有侵权请联系站长,我们将在72小时内删除。