C#判断字符串是否为空的三种方法及其比较

1.最普遍、最直接的方法

1.             string Input = "Yours Input Msg";
2.             if (Input == "")
3.                 ;

IL：

1.     .locals init ([0] string Input,[1] bool CS$4$0000)
2.     IL_0000:  nop
3.     IL_0001:  ldstr      "Yours Input Msg"
4.     IL_0006:  stloc.0
5.     IL_0007:  ldloc.0
6.     IL_0008:  ldstr      ""
7.     IL_000d:  call       bool [mscorlib]System.String::op_Equality(string,string)

 

2.使用String.Empty

1.             string Input = "Yours Input Msg";
2.             if (Input == String.Empty)
3.                 ;

IL：

1.     .locals init ([0] string Input,[1] bool CS$4$0000)
2.     IL_0000:  nop
3.     IL_0001:  ldstr      "Yours Input Msg"
4.     IL_0006:  stloc.0
5.     IL_0007:  ldloc.0
6.     IL_0008:  ldsfld     string [mscorlib]System.String::Empty
7.     IL_000d:  call       bool [mscorlib]System.String::op_Equality(string,string)

3.使用string.Length

1.             string Input = "Yours Input Msg";
2.             if (Input.Length == 0)
3.                 ;

 

IL：

1.     .locals init ([0] string Input,[1] bool CS$4$0000)
2.     IL_0000:  nop
3.     IL_0001:  ldstr      "Yours Input Msg"
4.     IL_0006:  stloc.0
5.     IL_0007:  ldloc.0
6.     IL_0008:  callvirt   instance int32 [mscorlib]System.String::get_Length()

在看过了三种方法之后，我们从底层开始进行比较，这里先做个假设，我们假设所有的单个IL语句执行时间相等，单位为1。(其实还是有差异的，但并不影响我们作比较。)

 

我们先反汇编mscorlib.dll得到System.String::op_Equality(strin,string)：

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

发现他还要调用这个函数System.String::Equals(strin,string)：

1.   .method public hidebysig virtual instance bool 
2.           Equals(object obj) cil managed
3.   {
4.     .custom instance void System.Runtime.ConstrainedExecution.ReliabilityContractAttribute::.ctor(valuetype System.Runtime.ConstrainedExecution.Consistency,
5.                                                                                                   valuetype System.Runtime.ConstrainedExecution.Cer) = ( 01 00 03 00 00 00 01 00 00 00 00 00 ) 
6.     // 代码大小       23 (0x17)
7.     .maxstack  2
8.     .locals init (string V_0)
9.     IL_0000:  ldarg.1
10.     IL_0001:  isinst     System.String
11.     IL_0006:  stloc.0
12.     IL_0007:  ldloc.0
13.     IL_0008:  brtrue.s   IL_000f
15.     IL_000a:  ldarg.0
16.     IL_000b:  brfalse.s  IL_000f
18.     IL_000d:  ldc.i4.0
19.     IL_000e:  ret
21.     IL_000f:  ldarg.0
22.     IL_0010:  ldloc.0
23.     IL_0011:  call       bool System.String::EqualsHelper(string,
24.                                                           string)
25.     IL_0016:  ret
26.   } // end of method String::Equals

然后还要调用System.String::EqualsHelper(string,string)：

1.   .method private hidebysig static bool  EqualsHelper(string strA,
2.                                                       string strB) cil managed
3.   {
4.     .custom instance void System.Runtime.ConstrainedExecution.ReliabilityContractAttribute::.ctor(valuetype System.Runtime.ConstrainedExecution.Consistency,
5.                                                                                                   valuetype System.Runtime.ConstrainedExecution.Cer) = ( 01 00 03 00 00 00 01 00 00 00 00 00 ) 
6.     // 代码大小       187 (0xbb)
7.     .maxstack  3
8.     .locals init (int32 V_0,
9.              char* V_1,
10.              char* V_2,
11.              char* V_3,
12.              char* V_4,
13.              bool V_5,
14.              string pinned V_6,
15.              string pinned V_7)
16.     IL_0000:  ldarg.0
17.     IL_0001:  callvirt   instance int32 System.String::get_Length()
18.     IL_0006:  stloc.0
19.     IL_0007:  ldloc.0
20.     IL_0008:  ldarg.1
21.     IL_0009:  callvirt   instance int32 System.String::get_Length()
22.     IL_000e:  beq.s      IL_0012
24.     IL_0010:  ldc.i4.0
25.     IL_0011:  ret
27.     IL_0012:  ldarg.0
28.     IL_0013:  stloc.s    V_6
29.     IL_0015:  ldloc.s    V_6
30.     IL_0017:  conv.i
31.     IL_0018:  dup
32.     IL_0019:  brfalse.s  IL_0021
34.     IL_001b:  call       int32 System.Runtime.CompilerServices.RuntimeHelpers::get_OffsetToStringData()
35.     IL_0020:  add
36.     IL_0021:  stloc.1
37.     IL_0022:  ldarg.1
38.     IL_0023:  stloc.s    V_7
39.     IL_0025:  ldloc.s    V_7
40.     IL_0027:  conv.i
41.     IL_0028:  dup
42.     IL_0029:  brfalse.s  IL_0031
44.     IL_002b:  call       int32 System.Runtime.CompilerServices.RuntimeHelpers::get_OffsetToStringData()
45.     IL_0030:  add
46.     IL_0031:  stloc.2
47.     IL_0032:  ldloc.1
48.     IL_0033:  stloc.3
49.     IL_0034:  ldloc.2
50.     IL_0035:  stloc.s    V_4
51.     IL_0037:  br.s       IL_008b
53.     IL_0039:  ldloc.3
54.     IL_003a:  ldind.i4
55.     IL_003b:  ldloc.s    V_4
56.     IL_003d:  ldind.i4
57.     IL_003e:  bne.un.s   IL_00a9
59.     IL_0040:  ldloc.3
60.     IL_0041:  ldc.i4.4
61.     IL_0042:  conv.i
62.     IL_0043:  add
63.     IL_0044:  ldind.i4
64.     IL_0045:  ldloc.s    V_4
65.     IL_0047:  ldc.i4.4
66.     IL_0048:  conv.i
67.     IL_0049:  add
68.     IL_004a:  ldind.i4
69.     IL_004b:  bne.un.s   IL_00a9
71.     IL_004d:  ldloc.3
72.     IL_004e:  ldc.i4.8
73.     IL_004f:  conv.i
74.     IL_0050:  add
75.     IL_0051:  ldind.i4
76.     IL_0052:  ldloc.s    V_4
77.     IL_0054:  ldc.i4.8
78.     IL_0055:  conv.i
79.     IL_0056:  add
80.     IL_0057:  ldind.i4
81.     IL_0058:  bne.un.s   IL_00a9
83.     IL_005a:  ldloc.3
84.     IL_005b:  ldc.i4.s   12
85.     IL_005d:  conv.i
86.     IL_005e:  add
87.     IL_005f:  ldind.i4
88.     IL_0060:  ldloc.s    V_4
89.     IL_0062:  ldc.i4.s   12
90.     IL_0064:  conv.i
91.     IL_0065:  add
92.     IL_0066:  ldind.i4
93.     IL_0067:  bne.un.s   IL_00a9
95.     IL_0069:  ldloc.3
96.     IL_006a:  ldc.i4.s   16
97.     IL_006c:  conv.i
98.     IL_006d:  add
99.     IL_006e:  ldind.i4
100.     IL_006f:  ldloc.s    V_4
101.     IL_0071:  ldc.i4.s   16
102.     IL_0073:  conv.i
103.     IL_0074:  add
104.     IL_0075:  ldind.i4
105.     IL_0076:  bne.un.s   IL_00a9
107.     IL_0078:  ldloc.3
108.     IL_0079:  ldc.i4.s   20
109.     IL_007b:  conv.i
110.     IL_007c:  add
111.     IL_007d:  stloc.3
112.     IL_007e:  ldloc.s    V_4
113.     IL_0080:  ldc.i4.s   20
114.     IL_0082:  conv.i
115.     IL_0083:  add
116.     IL_0084:  stloc.s    V_4
117.     IL_0086:  ldloc.0
118.     IL_0087:  ldc.i4.s   10
119.     IL_0089:  sub
120.     IL_008a:  stloc.0
121.     IL_008b:  ldloc.0
122.     IL_008c:  ldc.i4.s   10
123.     IL_008e:  bge.s      IL_0039
125.     IL_0090:  br.s       IL_00a9
127.     IL_0092:  ldloc.3
128.     IL_0093:  ldind.i4
129.     IL_0094:  ldloc.s    V_4
130.     IL_0096:  ldind.i4
131.     IL_0097:  bne.un.s   IL_00ad
133.     IL_0099:  ldloc.3
134.     IL_009a:  ldc.i4.4
135.     IL_009b:  conv.i
136.     IL_009c:  add
137.     IL_009d:  stloc.3
138.     IL_009e:  ldloc.s    V_4
139.     IL_00a0:  ldc.i4.4
140.     IL_00a1:  conv.i
141.     IL_00a2:  add
142.     IL_00a3:  stloc.s    V_4
143.     IL_00a5:  ldloc.0
144.     IL_00a6:  ldc.i4.2
145.     IL_00a7:  sub
146.     IL_00a8:  stloc.0
147.     IL_00a9:  ldloc.0
148.     IL_00aa:  ldc.i4.0
149.     IL_00ab:  bgt.s      IL_0092
151.     IL_00ad:  ldloc.0
152.     IL_00ae:  ldc.i4.0
153.     IL_00af:  cgt
154.     IL_00b1:  ldc.i4.0
155.     IL_00b2:  ceq
156.     IL_00b4:  stloc.s    V_5
157.     IL_00b6:  leave.s    IL_00b8
159.     IL_00b8:  ldloc.s    V_5
160.     IL_00ba:  ret
161.   } // end of method String::EqualsHelper

粗略估算了下，System.String::op_Equality(strin,string)执行时间大概是160。

这样方法1的大概运行时间是165，空间大概是220字节。方法2比只多了一次调用System.String::Empty(程序中的静态变量)

1.  .field public static initonly string Empty

因此运行运行时间基本同方法1一致，空间上节省了2字节（原因是方法1需要先建立一个string类型("")后，再进行判断），可以忽略不计。很多文章谈到C#判断空字符串不同方法性能的时候往往以此为据，而看过上面的IL之后，我却不这么认为，真正的性能差异体现在了System.String::op_Equality(string,string)和System.String::get_Length()这两个函数之上。

下面我们看一下System.String::get_Length()：

1.   .method public hidebysig specialname instance int32 
2.           get_Length() cil managed internalcall
3.   {
4.   } // end of method String::get_Length

这个函数的函数体居然是空的？为什么？那难道这个不起作用吗？我认为是cil managed internalcall这个起了作用，取得字符串（内存中一块连续的区域）长度是非常快的，可以由CPU直接完成（这个是我的猜测，目前关于internalcall我们仅仅知道internalcall在RuntimeType类里面则是很容易就能够找到，速度很快，性能很高，这个可能涉及到程序的编译原理，不懂~~~）

反正这个函数很快很快就是了，那么方法3的运行时间大概只有6，空间大概是20多。

这样，我们得到了一个令人吃惊的结论，方法3在时间上只有前两种方法的约1/28，空间约是1/9。

为什么这样，我也不明白，我希望高手来指出我叙述或者论证不当的地方。

 

 

 

那么我们是否可以就直接使用方法3了呢？

答案是否定的。在C#使用属性时一定要注意异常捕捉的问题。

String的Length属性返回此实例中Char对象的个数，在C#中字符串可以看成是由多个Char组成的字符数组，这样如果String为null的话问题就来了，当String置为null时，相当于一个没有实例化的字符串数组，用Length取一个没有实例化数组的长度，那么产生异常就在所难免了。

 

因此应该这么做：

1.             string Input = "Yours Input Msg";
2.             if (Input!=null && Input.Length==0)
3.                 ;

 

看一下IL：

 

1.     .locals init ([0] string Input,[1] bool CS$4$0000)
2.     IL_0000:  nop
3.     IL_0001:  ldstr      "Yours Input Msg"
4.     IL_0006:  stloc.0
5.     IL_0007:  ldloc.0
6.     IL_0008:  brfalse.s  IL_0018
8.     IL_000a:  ldloc.0
9.     IL_000b:  callvirt   instance int32 [mscorlib]System.String::get_Length()
10.     IL_0010:  ldc.i4.0
11.     IL_0011:  ceq
12.     IL_0013:  ldc.i4.0
13.     IL_0014:  ceq
14.     IL_0016:  br.s       IL_0019

运行时间大概是在5-13，空间越是30字节。这样，比起Input == ""这个方法，效率大约提高

13-30多倍（因为有短路运算），空间却只要1/7。

 

因此这些方法中判断字符串是否为空的最佳方法是：

1. desStr!=null && desStr.Length==0

 

 

本人初涉C#，很多东西掌握的都不是很好，如果你有自己的看法，请告知我，一起学习，一起进步：）