由浅入深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是否为空的方法，也有两种判断值是否相等的方法。下面我们来看看：

    class Program
    {
        static void Main(string[] args)
        {
            //判断字符串是否为空
            string str1 = "MyWord";
            if (str1 == "")
                ;
            if (str1 == string.Empty) 
                ;
            if (str1 != null && str1.Length== 0)
                ;
            if (string.IsNullOrEmpty(str1))
                ;
          }
    }

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

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // 代码大小       85 (0x55)
  .maxstack  2
//声明3个参数，分别是str1和bool值
  .locals init ([0] string str1,
           [1] bool CS$4$0000)
  IL_0000:  nop
//推送对元数据中存储的"MyWord"字符串的新对象引用 
  IL_0001:  ldstr      "MyWord"
//将"MyWord"压栈到参数0
  IL_0006:  stloc.0
 

 


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

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

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

//--------string空判断第四种方法  if (string.IsNullOrEmpty(str1))  --------  
  IL_0041:  ldloc.0
//直接调用系统System.String::IsNullOrEmpty(string)函数比对
  IL_0042:  call       bool [mscorlib]System.String::IsNullOrEmpty(string)
  IL_0047:  ldc.i4.0
  IL_0048:  ceq
  IL_004a:  stloc.1
  IL_004b:  ldloc.1
  IL_004c:  brtrue.s   IL_004e
} // end of method Program::Main

 4种方法的CIL分析

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

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

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

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

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

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

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

       

性能分析

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

请看cs代码如下：

    class Program
    {
        static void Main(string[] args)
        {
            //判断字符串是否为空
            string str1 = "MyWord";
            //第一种方法耗时计算
            Stopwatch sw1 = new Stopwatch();
            sw1.Start();
            if (str1 == "")
                ;
            sw1.Stop();
            //第二种方法耗时计算
            Stopwatch sw2 = new Stopwatch();
            sw2.Start();
            if (str1 == string.Empty) 
                ;
            sw2.Stop();
            //第三种方法耗时计算
            Stopwatch sw3 = new Stopwatch();
            sw3.Start();
            if (str1!=null&&str1.Length == 0)
                ;
            sw3.Stop();
            //第四种方法耗时计算
            Stopwatch sw4 = new Stopwatch();
            sw4.Start();
            if (string.IsNullOrEmpty(str1))
                ;
            sw4.Stop();

            Console.WriteLine(@"if (str1 == "")的判断时间是：" + sw1.Elapsed);
            Console.WriteLine(@"if (str1 == string.Empty)的判断时间是：" + sw2.Elapsed);
            Console.WriteLine(@"if (str1!=null&&str1.Length == 0)的判断时间是：" + sw3.Elapsed);
            Console.WriteLine(@"if (string.IsNullOrEmpty(str1)) 的判断时间是：" + sw4.Elapsed);
            Console.ReadLine();

        }

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

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

 

 

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

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

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

  

扩展阅读：

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

.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代码如下：

.method public hidebysig static bool  Equals(string a,
                                             string b) cil managed
{
  // 代码大小       22 (0x16)
  .maxstack  8
  IL_0000:  ldarg.0
  IL_0001:  ldarg.1
  IL_0002:  bne.un.s   IL_0006
  IL_0004:  ldc.i4.1
  IL_0005:  ret
  IL_0006:  ldarg.0
  IL_0007:  brfalse.s  IL_000c
  IL_0009:  ldarg.1
  IL_000a:  brtrue.s   IL_000e
  IL_000c:  ldc.i4.0
  IL_000d:  ret
  IL_000e:  ldarg.0
  IL_000f:  ldarg.1
  IL_0010:  call       bool System.String::EqualsHelper(string,
                                                        string)
  IL_0015:  ret
} // end of method String::Equals

  

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

.method private hidebysig static bool  EqualsHelper(string strA,
                                                    string strB) cil managed
{
  .custom instance void System.Security.SecuritySafeCriticalAttribute::.ctor() = ( 01 00 00 00 ) 
  .custom instance void System.Runtime.ConstrainedExecution.ReliabilityContractAttribute::.ctor(valuetype System.Runtime.ConstrainedExecution.Consistency,
                                                                                                valuetype System.Runtime.ConstrainedExecution.Cer) = ( 01 00 03 00 00 00 01 00 00 00 00 00 ) 
  // 代码大小       199 (0xc7)
  .maxstack  3
  .locals init (int32 V_0,
           char& pinned V_1,
           char& pinned V_2,
           char* V_3,
           char* V_4,
           bool V_5)
  IL_0000:  ldarg.0
  IL_0001:  callvirt   instance int32 System.String::get_Length()
  IL_0006:  stloc.0
  IL_0007:  ldloc.0
  IL_0008:  ldarg.1
  IL_0009:  callvirt   instance int32 System.String::get_Length()
  IL_000e:  beq.s      IL_0012
  IL_0010:  ldc.i4.0
  IL_0011:  ret
  IL_0012:  ldarg.0
  IL_0013:  ldflda     char System.String::m_firstChar
  IL_0018:  stloc.1
  IL_0019:  ldarg.1
  IL_001a:  ldflda     char System.String::m_firstChar
  IL_001f:  stloc.2
  IL_0020:  ldloc.1
  IL_0021:  conv.i
  IL_0022:  stloc.3
  IL_0023:  ldloc.2
  IL_0024:  conv.i
  IL_0025:  stloc.s    V_4
  IL_0027:  br.s       IL_0097
  IL_0029:  ldloc.3
  IL_002a:  ldind.i4
  IL_002b:  ldloc.s    V_4
  IL_002d:  ldind.i4
  IL_002e:  beq.s      IL_0038
  IL_0030:  ldc.i4.0
  IL_0031:  stloc.s    V_5
  IL_0033:  leave      IL_00c4
  IL_0038:  ldloc.3
  IL_0039:  ldc.i4.4
  IL_003a:  conv.i
  IL_003b:  add
  IL_003c:  ldind.i4
  IL_003d:  ldloc.s    V_4
  IL_003f:  ldc.i4.4
  IL_0040:  conv.i
  IL_0041:  add
  IL_0042:  ldind.i4
  IL_0043:  beq.s      IL_004a
  IL_0045:  ldc.i4.0
  IL_0046:  stloc.s    V_5
  IL_0048:  leave.s    IL_00c4
  IL_004a:  ldloc.3
  IL_004b:  ldc.i4.8
  IL_004c:  conv.i
  IL_004d:  add
  IL_004e:  ldind.i4
  IL_004f:  ldloc.s    V_4
  IL_0051:  ldc.i4.8
  IL_0052:  conv.i
  IL_0053:  add
  IL_0054:  ldind.i4
  IL_0055:  beq.s      IL_005c
  IL_0057:  ldc.i4.0
  IL_0058:  stloc.s    V_5
  IL_005a:  leave.s    IL_00c4
  IL_005c:  ldloc.3
  IL_005d:  ldc.i4.s   12
  IL_005f:  conv.i
  IL_0060:  add
  IL_0061:  ldind.i4
  IL_0062:  ldloc.s    V_4
  IL_0064:  ldc.i4.s   12
  IL_0066:  conv.i
  IL_0067:  add
  IL_0068:  ldind.i4
  IL_0069:  beq.s      IL_0070
  IL_006b:  ldc.i4.0
  IL_006c:  stloc.s    V_5
  IL_006e:  leave.s    IL_00c4
  IL_0070:  ldloc.3
  IL_0071:  ldc.i4.s   16
  IL_0073:  conv.i
  IL_0074:  add
  IL_0075:  ldind.i4
  IL_0076:  ldloc.s    V_4
  IL_0078:  ldc.i4.s   16
  IL_007a:  conv.i
  IL_007b:  add
  IL_007c:  ldind.i4
  IL_007d:  beq.s      IL_0084
  IL_007f:  ldc.i4.0
  IL_0080:  stloc.s    V_5
  IL_0082:  leave.s    IL_00c4
  IL_0084:  ldloc.3
  IL_0085:  ldc.i4.s   20
  IL_0087:  conv.i
  IL_0088:  add
  IL_0089:  stloc.3
  IL_008a:  ldloc.s    V_4
  IL_008c:  ldc.i4.s   20
  IL_008e:  conv.i
  IL_008f:  add
  IL_0090:  stloc.s    V_4
  IL_0092:  ldloc.0
  IL_0093:  ldc.i4.s   10
  IL_0095:  sub
  IL_0096:  stloc.0
  IL_0097:  ldloc.0
  IL_0098:  ldc.i4.s   10
  IL_009a:  bge.s      IL_0029
  IL_009c:  br.s       IL_00b5
  IL_009e:  ldloc.3
  IL_009f:  ldind.i4
  IL_00a0:  ldloc.s    V_4
  IL_00a2:  ldind.i4
  IL_00a3:  bne.un.s   IL_00b9
  IL_00a5:  ldloc.3
  IL_00a6:  ldc.i4.4
  IL_00a7:  conv.i
  IL_00a8:  add
  IL_00a9:  stloc.3
  IL_00aa:  ldloc.s    V_4
  IL_00ac:  ldc.i4.4
  IL_00ad:  conv.i
  IL_00ae:  add
  IL_00af:  stloc.s    V_4
  IL_00b1:  ldloc.0
  IL_00b2:  ldc.i4.2
  IL_00b3:  sub
  IL_00b4:  stloc.0
  IL_00b5:  ldloc.0
  IL_00b6:  ldc.i4.0
  IL_00b7:  bgt.s      IL_009e
  IL_00b9:  ldloc.0
  IL_00ba:  ldc.i4.0
  IL_00bb:  cgt
  IL_00bd:  ldc.i4.0
  IL_00be:  ceq
  IL_00c0:  stloc.s    V_5
  IL_00c2:  leave.s    IL_00c4
  IL_00c4:  ldloc.s    V_5
  IL_00c6:  ret
} // 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()函数：

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