StringBuilder类为何比string的简单拼接效率高

simplelam 2014-12-02

展开全文

string类型具有不可变性，对string字符串的操作（如拼接、Trim()等）都会在内存中产生一个新的字符串对象，在对字符串进行频繁修改的情况下，如在For循环中进行操作等，那么将会频繁的创建新的字符串对象，造成系统的不必要开销，所以这种情况下大家都推荐使用StringBuilder类来对字符串进行操作，那么到底是怎么实现的呢？

先用代码展示StringBuilder的基本操作：

1 StringBuilder sb = new StringBuilder();
2 sb.Append("Hello!");
3 sb.Append("World,").Append("and ").Append("C#");
4 
5 Console.WriteLine(sb.ToString());
6 
7 Console.Read();

一个简单的实现，可能朋友觉得第三行代码：sb.Append("World,").Append("and ").Append("C#");好怪异哦，没错，这正是StringBuilder类高效的一个典型实现，用Reflector工具进行反编译，得到Append(string value)方法如下：

 1 [SecuritySafeCritical, __DynamicallyInvokable]
 2 public unsafe StringBuilder Append(string value)
 3 {
 4     if (value != null)
 5     {
 6         char[] chunkChars = this.m_ChunkChars;
 7         int chunkLength = this.m_ChunkLength;
 8         int length = value.Length;
 9         int num3 = chunkLength + length;
10         if (num3 < chunkChars.Length)
11         {
12             if (length <= 2)
13             {
14                 if (length > 0)
15                 {
16                     chunkChars[chunkLength] = value[0];
17                 }
18                 if (length > 1)
19                 {
20                     chunkChars[chunkLength + 1] = value[1];
21                 }
22             }
23             else
24             {
25                 fixed (char* str = ((char*) value))
26                 {
27                     char* smem = str;
28                     fixed (char* chRef = &(chunkChars[chunkLength]))
29                     {
30                         string.wstrcpy(chRef, smem, length);
31                     }
32                 }
33             }
34             this.m_ChunkLength = num3;
35         }
36         else
37         {
38             this.AppendHelper(value);
39         }
40     }
41     return this;
42 }
43 
44  
45 
46

Append(string value)方法返回StringBuilder类型，前面代码用了非托管的代码实现，看不懂无碍，跟本主题关系不大，关键是最后这句：return this；返回当前的操作实例，读到这里，可能会有些恍然大悟了吧，没错，StringBuilder类对字符串的操作，是在实例的基础上修改，而不是像string类型那样不停的创建新的对象，达到了节约系统内存开销的问题。

现在仿照StringBuilder类做一个自己的IntBuilder类的实现，没有实际意义，只是为了展现：

 1 class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Intbuilder ib = new Intbuilder();
 6             ib.Add(2).Add(5).Add(7);
 7             Console.WriteLine(ib.Sum);
 8 
 9             Console.Read();
10         }
11     }
12 
13     class Intbuilder
14     {
15         private int _sum;
16         public int Sum 
17         {
18             get { return this._sum; } 
19         }
20 
21         public Intbuilder Add(int value)
22         {
23             this._sum += value;
24             return this;
25         }
26     }