StringBuilder类是如何实现的？每次追加时它是否在内部创建新的字符串对象？

Question

StringBuilder类是如何实现的？每次追加时它是否在内部创建新的字符串对象？

Answer 1

在.NET 2.0中,它在String内部使用该类.String只能在System命名空间之外不可变,所以StringBuilder可以这样做.

在.NET 4.0 String中更改为使用char[].

在2.0 StringBuilder看起来像这样

public sealed class StringBuilder : ISerializable
{
    // Fields
    private const string CapacityField = "Capacity";
    internal const int DefaultCapacity = 0x10;
    internal IntPtr m_currentThread;
    internal int m_MaxCapacity;
    internal volatile string m_StringValue; // HERE ----------------------
    private const string MaxCapacityField = "m_MaxCapacity";
    private const string StringValueField = "m_StringValue";
    private const string ThreadIDField = "m_currentThread";

但在4.0中它看起来像这样:

public sealed class StringBuilder : ISerializable
{
    // Fields
    private const string CapacityField = "Capacity";
    internal const int DefaultCapacity = 0x10;
    internal char[] m_ChunkChars; // HERE --------------------------------
    internal int m_ChunkLength;
    internal int m_ChunkOffset;
    internal StringBuilder m_ChunkPrevious;
    internal int m_MaxCapacity;
    private const string MaxCapacityField = "m_MaxCapacity";
    internal const int MaxChunkSize = 0x1f40;
    private const string StringValueField = "m_StringValue";
    private const string ThreadIDField = "m_currentThread";

显然,它从使用a string变为使用a char[].

编辑:更新了答案,以反映.NET 4中的变化(我刚刚发现).

Answer 2

接受的答案错过了一英里的标记.到显著的变化StringBuilder在4.0不是来自一个不安全的变化string来char[]-这是一个事实StringBuilder是,现在实际上是一个链表StringBuilder实例.

这种变化的原因应该是显而易见的:现在永远不需要重新分配缓冲区(这是一项昂贵的操作,因为除了分配更多内存外,还必须将旧缓冲区中的所有内容复制到新缓冲区中).

这意味着呼叫ToString()现在稍微慢一些,因为最后一个字符串需要计算的,但做大量的Append()作业现在显著更快.这适用于典型的用例StringBuilder:大量的呼叫Append(),然后是一次呼叫ToString().

你可以在这里找到基准.结论？新的链表StringBuilder使用了更多的内存,但对于典型的用例来说明显更快.

Answer 3

不是 - 它使用内部字符缓冲区.只有当缓冲区容量耗尽时,它才会分配新的缓冲区.追加操作将简单地添加到此缓冲区,当调用ToString()方法时将创建字符串对象 - 此后,由于每个传统字符串连接操作将创建新字符串,因此它适用于许多字符串连接.您还可以指定字符串构建器的初始容量,如果您对它有粗略的了解以避免多次分配.

编辑:人们指出我的理解是错误的.请忽略答案(我宁愿不删除它 - 它将作为我无知的证据:-)

Answer 4

我制作了一个小示例来演示 StringBuilder 如何在 .NET 4 中工作。合同是

public interface ISimpleStringBuilder
{
    ISimpleStringBuilder Append(string value);
    ISimpleStringBuilder Clear();
    int Lenght { get; }
    int Capacity { get; }
}

这是一个非常基本的实现

public class SimpleStringBuilder : ISimpleStringBuilder
{
    public const int DefaultCapacity = 32;

    private char[] _internalBuffer;

    public int Lenght { get; private set; }
    public int Capacity { get; private set; }

    public SimpleStringBuilder(int capacity)
    {
        Capacity = capacity;
        _internalBuffer = new char[capacity];
        Lenght = 0;
    }

    public SimpleStringBuilder() : this(DefaultCapacity) { }

    public ISimpleStringBuilder Append(string value)
    {
        char[] data = value.ToCharArray();

        //check if space is available for additional data
        InternalEnsureCapacity(data.Length);

        foreach (char t in data)
        {
            _internalBuffer[Lenght] = t;
            Lenght++;
        }

        return this;
    }

    public ISimpleStringBuilder Clear()
    {
        _internalBuffer = new char[Capacity];
        Lenght = 0;
        return this;
    }

    public override string ToString()
    {
        //use only non-null ('\0') characters
        var tmp = new char[Lenght];
        for (int i = 0; i < Lenght; i++)
        {
            tmp[i] = _internalBuffer[i];
        }
        return new string(tmp);
    }

    private void InternalExpandBuffer()
    {
        //double capacity by default
        Capacity *= 2;

        //copy to new array
        var tmpBuffer = new char[Capacity];
        for (int i = 0; i < _internalBuffer.Length; i++)
        {
            char c = _internalBuffer[i];
            tmpBuffer[i] = c;
        }
        _internalBuffer = tmpBuffer;
    }

    private void InternalEnsureCapacity(int additionalLenghtRequired)
    {
        while (Lenght + additionalLenghtRequired > Capacity)
        {
            //not enough space in the current buffer    
            //double capacity
            InternalExpandBuffer();
        }
    }
}

此代码不是线程安全的，不进行任何输入验证，并且不使用 System.String 的内部（不安全）魔法。然而，它确实演示了 StringBuilder 类背后的想法。

一些单元测试和完整的示例代码可以在github上找到。