浅谈 C#字符串构建利器 StringBuilder

StringBuilder builder = new StringBuilder();builder.Append("我和我的祖国");builder.Append(',');builder.Append("一刻也不能分割");builder.Append('。');builder.Append("无论我走到哪里,都留下一首赞歌。");builder.Append("我歌唱每一座高山,我歌唱每一条河。");builder.Append("袅袅炊烟,小小村落,路上一道辙。");builder.Append("我永远紧依着你的心窝,你用你那母亲的脉搏,和我诉说。");string result = builder.ToString();Console.WriteLine(result);

StringBuilder builder = new StringBuilder("我和我的祖国");//或者是指定StringBuilder的容量，这样的话StringBuilder初始可承载字符串的长度是16builder = new StringBuilder(16);

//可承载字符的最大容量,即可以拼接的字符串的长度internal int m_MaxCapacity;//承载【拼接字符串的char数组internal char[] m_ChunkChars;//默认的容量，即默认初始化m_ChunkChars的长度，也就是首次扩容触发的长度internal const int DefaultCapacity = 16;public StringBuilder(){    m_MaxCapacity = int.MaxValue;    m_ChunkChars = new char[DefaultCapacity];}

//声明初始化容量，即首次扩容触发的长度条件public StringBuilder(int capacity)//声明初始化容量，和最大容量即可以动态构建字符串的总长度public StringBuilder(int capacity, int maxCapacity)//用给定字符串初始化public StringBuilder(string? value)//用给定字符串初始化，并声明容量public StringBuilder(string? value, int capacity)//用一个字符串截取指定长度初始化，并声明最大容量public StringBuilder(string? value, int startIndex, int length, int capacity)

//可承载字符的最大容量,即可以拼接的字符串的长度internal int m_MaxCapacity;//承载【拼接字符串的char数组internal char[] m_ChunkChars;//默认的容量，即默认初始化m_ChunkChars的长度，也就是首次扩容触发的长度internal const int DefaultCapacity = 16;public StringBuilder(int capacity, int maxCapacity){    //指定容量不能大于最大容量    if (capacity > maxCapacity)    {        throw new ArgumentOutOfRangeException(nameof(capacity), SR.ArgumentOutOfRange_Capacity);    }    //最大容量不能小于1    if (maxCapacity < 1)    {        throw new ArgumentOutOfRangeException(nameof(maxCapacity), SR.ArgumentOutOfRange_SmallMaxCapacity);    }    //初始化容量不能小于0    if (capacity < 0)    {        throw new ArgumentOutOfRangeException(nameof(capacity), SR.Format(SR.ArgumentOutOfRange_MustBePositive, nameof(capacity)));    }    //如果指定容量等于0，则使用默认的容量    if (capacity == 0)    {        capacity = Math.Min(DefaultCapacity, maxCapacity);    }    //最大容量赋值    m_MaxCapacity = maxCapacity;    //分配指定容量的数组    m_ChunkChars = GC.AllocateUninitializedArray<char>(capacity);}

//可承载字符的最大容量,即可以拼接的字符串的长度internal int m_MaxCapacity;//承载【拼接字符串的char数组internal char[] m_ChunkChars;//默认的容量，即默认初始化m_ChunkChars的长度，也就是首次扩容触发的长度internal const int DefaultCapacity = 16;//当前m_ChunkChars字符数组中已经使用的长度internal int m_ChunkLength;public StringBuilder(string? value, int startIndex, int length, int capacity){    if (capacity < 0)    {        throw new ArgumentOutOfRangeException();    }    if (length < 0)    {        throw new ArgumentOutOfRangeException();    }    if (startIndex < 0)    {        throw new ArgumentOutOfRangeException();    }    //初始化的字符串可以为null,如果为null则只用空字符串即""    if (value == null)    {        value = string.Empty;    }    //基础长度判断,这个逻辑其实已经包含了针对字符串截取的起始位置和接要截取的长度进行判断了    if (startIndex > value.Length - length)    {        throw new ArgumentOutOfRangeException();    }    //最大容量是int的最大值，即2^31-1    m_MaxCapacity = int.MaxValue;    if (capacity == 0)    {        capacity = DefaultCapacity;    }    //虽然传递了默认容量,但是这里依然做了判断,在传递的默认容量和需要存储的字符串容量总取最大值    capacity = Math.Max(capacity, length);    //分配指定容量的数组    m_ChunkChars = GC.AllocateUninitializedArray<char>(capacity);    //这里记录了m_ChunkChars固定长度的快中已经被使用的长度    m_ChunkLength = length;    //把传递的字符串指定位置指定长度(即截取操作)copy到m_ChunkChars中    value.AsSpan(startIndex, length).CopyTo(m_ChunkChars);}

//承载【拼接字符串的char数组internal char[] m_ChunkChars;//当前m_ChunkChars字符数组中已经使用的长度internal int m_ChunkLength;public StringBuilder Append(string? value){    if (value != null)    {        // 获取当前存储块        char[] chunkChars = m_ChunkChars;        // 获取当前块已使用的长度        int chunkLength = m_ChunkLength;        // 获取传进来的字符的长度        int valueLen = value.Length;
        //当前使用的长度 + 需要Append的长度 < 当前块的长度 则不需要扩容        if (((uint)chunkLength + (uint)valueLen) < (uint)chunkChars.Length)        {            //判断传进来的字符串长度是否<=2            //如果小于2则只用直接访问位置的方式操作            if (valueLen <= 2)            {                //判断字符串长度>0的场景                if (valueLen > 0)                {                    //m_ChunkChars的已使用长度其实就是可以Append新元素的起始位置                    //直接取value得第0个元素放入m_ChunkChars[可存储的起始位置]                    chunkChars[chunkLength] = value[0];                }                //其实是判断字符串长度==2的场景                if (valueLen > 1)                {                    //因为上面已经取了value第0个元素放入了m_ChunkChars中                    //现在则取value得第1个元素继续放入chunkLength的下一位置                    chunkChars[chunkLength + 1] = value[1];                }            }            else            {                //如果value的长度大于2则通过操作内存去追加value                //获取m_ChunkChars的引用位置,偏移到m_ChunkLength的位置追加value                Buffer.Memmove(                    ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(chunkChars), chunkLength),                    ref value.GetRawStringData(),                    (nuint)valueLen);            }            //更新以使用长度的值,新的使用长度是当前已使用长度+追加进来的字符串长度            m_ChunkLength = chunkLength + valueLen;        }        else        {            //走到这里说明进入了扩容逻辑            AppendHelper(value);        }    }    return this;}

private void AppendHelper(string value){    unsafe    {        //防止垃圾收集器重新定位value变量。        //指针操作,string本身是不可变的char数组,所以它的指针是char*         fixed (char* valueChars = value)        {            //调用了另一个append            Append(valueChars, value.Length);        }    }}

public unsafe StringBuilder Append(char* value, int valueCount){    // value必须有值    if (valueCount < 0)    {        throw new ArgumentOutOfRangeException();    }
    //新的长度=StringBuilder的长度+需要追加的字符串长度    int newLength = Length + valueCount;    //新的长度不能大于最大容量    if (newLength > m_MaxCapacity || newLength < valueCount)    {        throw new ArgumentOutOfRangeException();    }
    // 新的起始位置=需要追加的长度+当前使用的长度    int newIndex = valueCount + m_ChunkLength;    // 判断当前m_ChunkChars的容量是否够用    if (newIndex <= m_ChunkChars.Length)    {        //够用的话则直接将追加的元素添加到m_ChunkChars中去        new ReadOnlySpan<char>(value, valueCount).CopyTo(m_ChunkChars.AsSpan(m_ChunkLength));        //更新已使用的长度为新的长度        m_ChunkLength = newIndex;    }    //当前m_ChunkChars不满足存储则需要扩容    else    {        // 判断当前存储块m_ChunkChars还有多少未存储的位置        int firstLength = m_ChunkChars.Length - m_ChunkLength;        if (firstLength > 0)        {            //把需要追加的value中的前firstLength位字符copy到m_ChunkChars中剩余的位置            //合理的利用存储空间,截取需要追加的value到m_ChunkChars剩余的位置            new ReadOnlySpan<char>(value, firstLength).CopyTo(m_ChunkChars.AsSpan(m_ChunkLength));            //更新已使用的位置，这个时候当前存块m_ChunkChars已经存储满了            m_ChunkLength = m_ChunkChars.Length;        }
        // 获取value中未放入到m_ChunkChars(因为当前块已经放满)剩余部分起始位置        int restLength = valueCount - firstLength;        //扩展当前存储块即扩容操作        ExpandByABlock(restLength);        //判断新的存储块是否创建成功        Debug.Assert(m_ChunkLength == 0, "A new block was not created.");        // 将value中未放入到m_ChunkChars的剩余部放入扩容后的m_ChunkChars中去        new ReadOnlySpan<char>(value + firstLength, restLength).CopyTo(m_ChunkChars);        // 更新当前已使用长度        m_ChunkLength = restLength;    }    //一些针对当前StringBuilder的校验操作,和相关逻辑无关不做详细介绍    //类似的Debug.Assert(m_ChunkOffset + m_ChunkChars.Length >= m_ChunkOffset, "The length of the string is greater than int.MaxValue.");    AssertInvariants();    return this;}

public int Length{    //StringBuilder已存储的长度=块的偏移量+当前块使用的长度    get => m_ChunkOffset + m_ChunkLength;    set    {        //注意这里是有代码的只是我们暂时省略set逻辑    }}

//当前StringBuilder实际存储的总长度public int Length{    //StringBuilder已存储的长度=块的偏移量+当前块使用的长度    get => m_ChunkOffset + m_ChunkLength;    set    {        //注意这里是有代码的只是我们暂时省略set逻辑    }}//当前StringBuilder的总容量public int Capacity{    get => m_ChunkChars.Length + m_ChunkOffset;    set    {        //注意这里是有代码的只是我们暂时省略set逻辑    }}
//可承载字符的最大容量,即可以拼接的字符串的长度internal int m_MaxCapacity;//承载【拼接字符串的char数组internal char[] m_ChunkChars;//当前块的最大长度internal const int MaxChunkSize = 8000;//当前m_ChunkChars字符数组中已经使用的长度internal int m_ChunkLength;//存储块的偏移量,用于计算总长度internal int m_ChunkOffset;//前一个存储块internal StringBuilder? m_ChunkPrevious;private void ExpandByABlock(int minBlockCharCount){    //当前块m_ChunkChars存储满才进行扩容操作    Debug.Assert(Capacity == Length, nameof(ExpandByABlock) + " should only be called when there is no space left.");    //minBlockCharCount指的是剩下的需要存储的长度    Debug.Assert(minBlockCharCount > 0);    AssertInvariants();
    //StringBuilder的总长度不能大于StringBuilder的m_MaxCapacity    if ((minBlockCharCount + Length) > m_MaxCapacity || minBlockCharCount + Length < minBlockCharCount)    {        throw new ArgumentOutOfRangeException();    }
    //!!!需要扩容块的新长度=max(当前追加字符的剩余长度,min(当前StringBuilder长度,8000))    int newBlockLength = Math.Max(minBlockCharCount, Math.Min(Length, MaxChunkSize));
    //判断长度是否越界    if (m_ChunkOffset + m_ChunkLength + newBlockLength < newBlockLength)    {        throw new OutOfMemoryException();    }
    // 申请一个新的存块长度为newBlockLength    char[] chunkChars = GC.AllocateUninitializedArray<char>(newBlockLength);
    //!!!把当前StringBuilder中的存储块存放到一个新的StringBuilder实例中，当前实例的m_ChunkPrevious指向上一个StringBuilder    //这里可以看出来扩容的本质是构建节点为StringBuilder的链表    m_ChunkPrevious = new StringBuilder(this);    //偏移量是每次扩容的时候去修改,它的长度就是记录了已使用块的长度,但是不包含当前StringBuilder的存储块    //可以理解为偏移量=长度-已经存放扩容块的长度    m_ChunkOffset += m_ChunkLength;    //因为已经扩容了新的容器所以重置已使用长度    m_ChunkLength = 0;    //把新的块重新赋值给当前存储块m_ChunkChars数组    m_ChunkChars = chunkChars;    AssertInvariants();}

private StringBuilder(StringBuilder from){    m_ChunkLength = from.m_ChunkLength;    m_ChunkOffset = from.m_ChunkOffset;    m_ChunkChars = from.m_ChunkChars;    m_ChunkPrevious = from.m_ChunkPrevious;    m_MaxCapacity = from.m_MaxCapacity;    AssertInvariants();}

//当前StringBuilder实际存储的总长度public int Length{    //StringBuilder已存储的长度=块的偏移量+当前块使用的长度    get => m_ChunkOffset + m_ChunkLength;    set    {        //注意这里是有代码的只是我们暂时省略set逻辑    }}public override string ToString(){    AssertInvariants();    //当前StringBuilder长度为0则直接返回空字符串    if (Length == 0)    {        return string.Empty;    }    //FastAllocateString函数负责分配长度为StringBuilder长度的字符串    //这个字符串就是ToString最终返回的结果,所以长度等于StringBuilder的长度    string result = string.FastAllocateString(Length);    //当前StringBuilder是遍历的第一个链表节点    StringBuilder? chunk = this;    do    {        //当前使用长度必须大于0，也就是说当前块的m_ChunkChars必须使用过,才需要遍历当前节点        if (chunk.m_ChunkLength > 0)        {            // 取出当前遍历的StringBuilder的相关数据            // 当前遍历StringBuilder的m_ChunkChars            char[] sourceArray = chunk.m_ChunkChars;            int chunkOffset = chunk.m_ChunkOffset;            int chunkLength = chunk.m_ChunkLength;
            // 检查是否越界            if ((uint)(chunkLength + chunkOffset) > (uint)result.Length || (uint)chunkLength > (uint)sourceArray.Length)            {                throw new ArgumentOutOfRangeException();            }            //把当前遍历项StringBuilder的m_ChunkChars逐步添加到result中当前结果的前端            Buffer.Memmove(                ref Unsafe.Add(ref result.GetRawStringData(), chunkOffset),                ref MemoryMarshal.GetArrayDataReference(sourceArray),                (nuint)chunkLength);        }        //获取当前StringBuilder的前一个节点,循环遍历链表操作        chunk = chunk.m_ChunkPrevious;    }    //如果m_ChunkPrevious==null则代表是第一个节点    while (chunk != null);
    return result;}

//初始化一个等于StringBuilder长度的字符串string result = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";//第一次遍历后result = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0无论我走到哪里都留下一首赞歌。";//第二次遍历后result = "\0\0\0\0\0\0\0一刻也不能分割,无论我走到哪里都留下一首赞歌。";//第三次遍历后result = "\0\0\0我的祖国一刻也不能分割,无论我走到哪里都留下一首赞歌。";//第三次遍历后result = "我和我的祖国一刻也不能分割,无论我走到哪里都留下一首赞歌。";

//存储块也就是承载Append数据的容器char[] value;//StringBuilder的总长度int count;public StringBuilder() {    //默认的容量也是16    super(16);}
public StringBuilder(String str) {    //这个地方有差异如果通过指定字符串初始化StringBuilder    //则初始化的长度则是当前传递的str的长度+16    super(str.length() + 16);    append(str);}
// AbstractStringBuilder.javaAbstractStringBuilder(int capacity) {    value = new char[capacity];}

// AbstractStringBuilder.javapublic AbstractStringBuilder append(String str) {    if (str == null)        return appendNull();    int len = str.length();    // 这里是扩容操作    ensureCapacityInternal(count + len);    str.getChars(0, len, value, count);    //每次append之后重新设置长度    count += len;    return this;} 

private void ensureCapacityInternal(int minimumCapacity) {    //当前需要的长度>char[]的长度则需要扩容    if (minimumCapacity - value.length > 0)        expandCapacity(minimumCapacity);}
void expandCapacity(int minimumCapacity) {    //新扩容的长度是当前块char[]的长度的2倍+2    int newCapacity = value.length * 2 + 2;    if (newCapacity - minimumCapacity < 0)        newCapacity = minimumCapacity;    if (newCapacity < 0) {        if (minimumCapacity < 0)            throw new OutOfMemoryError();        newCapacity = Integer.MAX_VALUE;    }    //把当前的char[]复制到新扩容的字符数组中    value = Arrays.copyOf(value, newCapacity);}
// Arrays.java copy的逻辑public static char[] copyOf(char[] original, int newLength) {    //声明一个新的数组，把original的数据copy到新的char数组中    char[] copy = new char[newLength];    System.arraycopy(original, 0, copy, 0,                     Math.min(original.length, newLength));    return copy;}

@Overridepublic String toString() {    // 这里创建了一个新的String对象返回，通过当前char[]初始化这个字符串    return new String(value, 0, count);}