csharp | string vs stringbuilder

介绍

在C#编程中，string和StringBuilder是两种常用的字符串类型，它们在应用场景和性能上有着明显的差异。string是不可变的字符串类型，一旦创建就不能修改，因此它适用于需要频繁读取而不需要修改的场景；而StringBuilder是可变的字符串类型，可以在原有的字符串上进行修改，适用于需要频繁修改字符串的场景。

本文将从定义、区别、应用场景和性能等方面介绍string和StringBuilder的差异，并进行性能比较，希望能够帮助读者更好地理解和应用这两种字符串类型

string和StringBuilder的基本概念

string

string是C#中的一种不可变字符串类型，表示一个字符串对象，它存储在堆内存中。一旦创建了一个string对象，就不能修改它的值，而是创建一个新的string对象。这种不可变性带来了一些优点，例如更安全、更容易缓存、更容易共享等，但也带来了一些性能问题，例如频繁地创建和销毁对象会占用大量的内存和CPU时间。

StringBuilder

StringBuilder是C#中的一种可变字符串类型，表示一个字符串缓冲区，它也存储在堆内存中。与string不同，StringBuilder对象可以在原有的字符串缓冲区上进行修改，而不需要创建新的对象。因此，StringBuilder适用于需要频繁修改字符串的场景，例如字符串连接、替换、插入等。

需要注意的是，StringBuilder对象是可变的，但不是线程安全的，因此在多线程环境下，需要采取措施来确保线程安全。可以使用锁或者使用ThreadLocal类创建多个StringBuilder对象，每个线程独立使用一个StringBuilder对象，以确保线程安全。

区别

string和StringBuilder的定义和用法

在C#中，string和StringBuilder都是用于表示字符串的类型。它们的定义和用法有所不同：

string:

string str = "hello";

StringBuilder：

StringBuilder sb = new StringBuilder("hello");

string对象是不可变的，一旦创建了一个string对象，就不能修改它的值，而是创建一个新的string对象。StringBuilder对象是可变的，可以在原有的字符串缓冲区上进行修改，而不需要创建新的对象。

内存分配和管理

string和StringBuilder的内存分配和管理方式也不同。

string对象的内存是在堆内存上分配的，它的生命周期由垃圾回收器控制。当string对象不再被引用时，它的内存将被垃圾回收器自动回收。

StringBuilder对象也是在堆内存上分配的，但是它使用了可变大小的内部缓冲区。当StringBuilder对象的缓冲区不足以存储新的字符时，它会自动重新分配一个更大的缓冲区，同时将旧的缓冲区释放掉。这个过程会导致一定的性能开销，但是可以避免频繁创建和销毁对象，从而减少了内存压力。

字符串连接和修改方式

string和StringBuilder的字符串连接和修改方式也不同。

对于string对象，每次连接两个字符串时，都会创建一个新的string对象，这样会导致频繁地创建和销毁对象，从而占用大量的内存和CPU时间。

例如：

string str = "hello";
str += " world";

上述代码会创建两个string对象，一个是"hello"，另一个是" world"，然后再将它们连接起来，创建一个新的string对象"hello world"。这个过程中创建了三个string对象，即"hello"、" world"和"hello world"。

对于StringBuilder对象，每次连接两个字符串时，它会在原有的字符串缓冲区上进行修改，而不需要创建新的对象。这样可以避免频繁地创建和销毁对象，从而减少了内存和CPU的开销。

例如：

StringBuilder sb = new StringBuilder("hello");
sb.Append(" world");

上述代码只创建了一个StringBuilder对象，然后在它的缓冲区上添加了一个新的字符串" world"，最终得到的字符串是"hello world"。这个过程中只创建了一个StringBuilder对象，没有创建任何新的string对象。

总之，string适用于需要频繁读取而不需要修改的场景，而StringBuilder适用于需要频繁修改字符串的场景。需要根据实际的业务需求选择合适的字符串类型。

应用场景

string的适用场景

string适用于需要频繁读取而不需要修改的场景，例如：

字符串常量
字符串的比较、查找、截取等操作
字符串的格式化输出

例如：

string str1 = "hello"; // 字符串常量
string str2 = "world";
string str3 = str1 + " " + str2; // 字符串连接
if (str1.Equals("hello")) // 字符串比较
{
    Console.WriteLine("str1 equals hello");
}
string substr = str3.Substring(0, 5); // 字符串截取
Console.WriteLine(substr);
string formatstr = string.Format("str1={0}, str2={1}", str1, str2); // 字符串格式化输出
Console.WriteLine(formatstr);

StringBuilder的适用场景

StringBuilder适用于需要频繁修改字符串的场景，例如：

大量字符串的连接
大量字符串的替换、插入等操作

例如：

StringBuilder sb = new StringBuilder("hello");
for (int i = 0; i < 10000; i++)
{
    sb.Append(" world"); // 大量字符串的连接
}
string str = sb.ToString();
Console.WriteLine(str);
sb.Replace("world", "csharp"); // 大量字符串的替换
sb.Insert(0, "welcome to "); // 大量字符串的插入
string newstr = sb.ToString();
Console.WriteLine(newstr);

总之，需要根据实际的业务需求选择合适的字符串类型，避免不必要的性能开销。如果需要频繁修改字符串，建议使用StringBuilder，否则可以使用string。同时，对于大量的字符串操作，建议使用StringBuilder，可以避免频繁地创建和销毁string对象，提高性能。

性能比较

对于字符串的操作，性能是一个非常重要的指标。下面通过实验对比string和StringBuilder的性能。

实验方法

通过一个循环，分别使用string和StringBuilder对字符串进行10000次的连接操作，然后计算每次操作的耗时。具体代码如下：

using System;
using System.Diagnostics;
using System.Text;

namespace StringTest
{
    class Program
    {
        static void Main(string[] args)
        {
            // test string
            string str = "";
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int i = 0; i < 10000; i++)
            {
                str += "hello world";
            }
            sw.Stop();
            Console.WriteLine("test string: " + sw.ElapsedMilliseconds + " ms");

            // test StringBuilder
            StringBuilder sb = new StringBuilder();
            sw.Reset();
            sw.Start();
            for (int i = 0; i < 10000; i++)
            {
                sb.Append("hello world");
            }
            sw.Stop();
            Console.WriteLine("test StringBuilder: " + sw.ElapsedMilliseconds + " ms");
        }
    }
}

比较结果

在我的机器上，运行以上代码，得到的实验结果如下：

test string: 235 ms
test StringBuilder: 0 ms

可以看到，使用string进行字符串连接的耗时是235毫秒，而使用StringBuilder进行字符串连接的耗时只有0毫秒，相差非常明显。

这是因为，string在进行字符串连接时，每次连接都会创建一个新的string对象，而原有的string对象则成为垃圾对象，需要进行垃圾回收。而StringBuilder则通过修改自身的内部缓冲区来进行字符串连接，避免了频繁创建和销毁string对象，因此速度更快。

因此，对于大量字符串的连接操作，建议使用StringBuilder，可以显著提高性能。

总结

本文介绍了C#编程中string和StringBuilder的区别、各自的应用场景和性能比较。

可以看到，string适用于需要频繁读取而不需要修改的场景，例如字符串常量、比较、查找、截取、格式化输出等操作。而StringBuilder适用于需要频繁修改字符串的场景，例如大量字符串的连接、替换、插入等操作。

在性能方面，使用string进行字符串连接的耗时是比较大的，而使用StringBuilder进行字符串连接的耗时则很小，可以显著提高性能。因此，对于大量字符串的连接操作，建议使用StringBuilder，避免不必要的性能开销。

总之，根据实际的业务需求选择合适的字符串类型，可以有效地提高程序的性能和效率。

参考文献

[1] Microsoft Docs. String Class. https://docs.microsoft.com/en-us/dotnet/api/system.string?view=net-6.0

[2] Microsoft Docs. StringBuilder Class. https://docs.microsoft.com/en-us/dotnet/api/system.text.stringbuilder?view=net-6.0

[3] C# Program Examples. Difference between String and StringBuilder in C#. https://www.c-sharpcorner.com/article/difference-between-string-and-stringbuilder-in-c-sharp/