StringBuilder builder = new StringBuilder();
builder.Append("我和我的祖國(guó)");
builder.Append(',');
builder.Append("一刻也不能分割");
builder.Append('。');
builder.Append("無論我走到哪里,都留下一首贊歌。");
builder.Append("我歌唱每一座高山,我歌唱每一條河。");
builder.Append("裊裊炊煙,小小村落,路上一道轍。");
builder.Append("我永遠(yuǎn)緊依著你的心窩,你用你那母親的脈搏,和我訴說。");
string result = builder.ToString();
Console.WriteLine(result);

StringBuilder builder = new StringBuilder("我和我的祖國(guó)");
//或者是指定StringBuilder的容量，這樣的話StringBuilder初始可承載字符串的長(zhǎng)度是16
builder = new StringBuilder(16);

//可承載字符的最大容量,即可以拼接的字符串的長(zhǎng)度
internal int m_MaxCapacity;
//承載【拼接字符串的char數(shù)組
internal char[] m_ChunkChars;
//默認(rèn)的容量，即默認(rèn)初始化m_ChunkChars的長(zhǎng)度，也就是首次擴(kuò)容觸發(fā)的長(zhǎng)度
internal const int DefaultCapacity = 16;
public StringBuilder()
{
    m_MaxCapacity = int.MaxValue;
    m_ChunkChars = new char[DefaultCapacity];
}

//聲明初始化容量，即首次擴(kuò)容觸發(fā)的長(zhǎng)度條件
public StringBuilder(int capacity)
//聲明初始化容量，和最大容量即可以動(dòng)態(tài)構(gòu)建字符串的總長(zhǎng)度
public StringBuilder(int capacity, int maxCapacity)
//用給定字符串初始化
public StringBuilder(string? value)
//用給定字符串初始化，并聲明容量
public StringBuilder(string? value, int capacity)
//用一個(gè)字符串截取指定長(zhǎng)度初始化，并聲明最大容量
public StringBuilder(string? value, int startIndex, int length, int capacity)

//可承載字符的最大容量,即可以拼接的字符串的長(zhǎng)度
internal int m_MaxCapacity;
//承載【拼接字符串的char數(shù)組
internal char[] m_ChunkChars;
//默認(rèn)的容量，即默認(rèn)初始化m_ChunkChars的長(zhǎng)度，也就是首次擴(kuò)容觸發(fā)的長(zhǎng)度
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，則使用默認(rèn)的容量
    if (capacity == 0)
    {
        capacity = Math.Min(DefaultCapacity, maxCapacity);
    }
    //最大容量賦值
    m_MaxCapacity = maxCapacity;
    //分配指定容量的數(shù)組
    m_ChunkChars = GC.AllocateUninitializedArray<char>(capacity);
}

//可承載字符的最大容量,即可以拼接的字符串的長(zhǎng)度
internal int m_MaxCapacity;
//承載【拼接字符串的char數(shù)組
internal char[] m_ChunkChars;
//默認(rèn)的容量，即默認(rèn)初始化m_ChunkChars的長(zhǎng)度，也就是首次擴(kuò)容觸發(fā)的長(zhǎng)度
internal const int DefaultCapacity = 16;
//當(dāng)前m_ChunkChars字符數(shù)組中已經(jīng)使用的長(zhǎng)度
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;
    }
    //基礎(chǔ)長(zhǎng)度判斷,這個(gè)邏輯其實(shí)已經(jīng)包含了針對(duì)字符串截取的起始位置和接要截取的長(zhǎng)度進(jìn)行判斷了
    if (startIndex > value.Length - length)
    {
        throw new ArgumentOutOfRangeException();
    }
    //最大容量是int的最大值，即2^31-1
    m_MaxCapacity = int.MaxValue;
    if (capacity == 0)
    {
        capacity = DefaultCapacity;
    }
    //雖然傳遞了默認(rèn)容量,但是這里依然做了判斷,在傳遞的默認(rèn)容量和需要存儲(chǔ)的字符串容量總?cè)∽畲笾?
    capacity = Math.Max(capacity, length);
    //分配指定容量的數(shù)組
    m_ChunkChars = GC.AllocateUninitializedArray<char>(capacity);
    //這里記錄了m_ChunkChars固定長(zhǎng)度的快中已經(jīng)被使用的長(zhǎng)度
    m_ChunkLength = length;
    //把傳遞的字符串指定位置指定長(zhǎng)度(即截取操作)copy到m_ChunkChars中
    value.AsSpan(startIndex, length).CopyTo(m_ChunkChars);
}

//承載【拼接字符串的char數(shù)組
internal char[] m_ChunkChars;
//當(dāng)前m_ChunkChars字符數(shù)組中已經(jīng)使用的長(zhǎng)度
internal int m_ChunkLength;
public StringBuilder Append(string? value)
{
    if (value != null)
    {
        // 獲取當(dāng)前存儲(chǔ)塊
        char[] chunkChars = m_ChunkChars;
        // 獲取當(dāng)前塊已使用的長(zhǎng)度
        int chunkLength = m_ChunkLength;
        // 獲取傳進(jìn)來的字符的長(zhǎng)度
        int valueLen = value.Length;

        //當(dāng)前使用的長(zhǎng)度 + 需要Append的長(zhǎng)度 < 當(dāng)前塊的長(zhǎng)度 則不需要擴(kuò)容
        if (((uint)chunkLength + (uint)valueLen) < (uint)chunkChars.Length)
        {
            //判斷傳進(jìn)來的字符串長(zhǎng)度是否<=2
            //如果小于2則只用直接訪問位置的方式操作
            if (valueLen <= 2)
            {
                //判斷字符串長(zhǎng)度>0的場(chǎng)景
                if (valueLen > 0)
                {
                    //m_ChunkChars的已使用長(zhǎng)度其實(shí)就是可以Append新元素的起始位置
                    //直接取value得第0個(gè)元素放入m_ChunkChars[可存儲(chǔ)的起始位置]
                    chunkChars[chunkLength] = value[0];
                }
                //其實(shí)是判斷字符串長(zhǎng)度==2的場(chǎng)景
                if (valueLen > 1)
                {
                    //因?yàn)樯厦嬉呀?jīng)取了value第0個(gè)元素放入了m_ChunkChars中
                    //現(xiàn)在則取value得第1個(gè)元素繼續(xù)放入chunkLength的下一位置
                    chunkChars[chunkLength + 1] = value[1];
                }
            }
            else
            {
                //如果value的長(zhǎng)度大于2則通過操作內(nèi)存去追加value
                //獲取m_ChunkChars的引用位置,偏移到m_ChunkLength的位置追加value
                Buffer.Memmove(
                    ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(chunkChars), chunkLength),
                    ref value.GetRawStringData(),
                    (nuint)valueLen);
            }
            //更新以使用長(zhǎng)度的值,新的使用長(zhǎng)度是當(dāng)前已使用長(zhǎng)度+追加進(jìn)來的字符串長(zhǎng)度
            m_ChunkLength = chunkLength + valueLen;
        }
        else
        {
            //走到這里說明進(jìn)入了擴(kuò)容邏輯
            AppendHelper(value);
        }
    }
    return this;
}

private void AppendHelper(string value)
{
    unsafe
    {
        //防止垃圾收集器重新定位value變量。
        //指針操作,string本身是不可變的char數(shù)組,所以它的指針是char* 
        fixed (char* valueChars = value)
        {
            //調(diào)用了另一個(gè)append
            Append(valueChars, value.Length);
        }
    }
}

public unsafe StringBuilder Append(char* value, int valueCount)
{
    // value必須有值
    if (valueCount < 0)
    {
        throw new ArgumentOutOfRangeException();
    }

    //新的長(zhǎng)度=StringBuilder的長(zhǎng)度+需要追加的字符串長(zhǎng)度
    int newLength = Length + valueCount;
    //新的長(zhǎng)度不能大于最大容量
    if (newLength > m_MaxCapacity || newLength < valueCount)
    {
        throw new ArgumentOutOfRangeException();
    }

    // 新的起始位置=需要追加的長(zhǎng)度+當(dāng)前使用的長(zhǎng)度
    int newIndex = valueCount + m_ChunkLength;
    // 判斷當(dāng)前m_ChunkChars的容量是否夠用
    if (newIndex <= m_ChunkChars.Length)
    {
        //夠用的話則直接將追加的元素添加到m_ChunkChars中去
        new ReadOnlySpan<char>(value, valueCount).CopyTo(m_ChunkChars.AsSpan(m_ChunkLength));
        //更新已使用的長(zhǎng)度為新的長(zhǎng)度
        m_ChunkLength = newIndex;
    }
    //當(dāng)前m_ChunkChars不滿足存儲(chǔ)則需要擴(kuò)容
    else
    {
        // 判斷當(dāng)前存儲(chǔ)塊m_ChunkChars還有多少未存儲(chǔ)的位置
        int firstLength = m_ChunkChars.Length - m_ChunkLength;
        if (firstLength > 0)
        {
            //把需要追加的value中的前firstLength位字符copy到m_ChunkChars中剩余的位置
            //合理的利用存儲(chǔ)空間,截取需要追加的value到m_ChunkChars剩余的位置
            new ReadOnlySpan<char>(value, firstLength).CopyTo(m_ChunkChars.AsSpan(m_ChunkLength));
            //更新已使用的位置，這個(gè)時(shí)候當(dāng)前存塊m_ChunkChars已經(jīng)存儲(chǔ)滿了
            m_ChunkLength = m_ChunkChars.Length;
        }

        // 獲取value中未放入到m_ChunkChars(因?yàn)楫?dāng)前塊已經(jīng)放滿)剩余部分起始位置
        int restLength = valueCount - firstLength;
        //擴(kuò)展當(dāng)前存儲(chǔ)塊即擴(kuò)容操作
        ExpandByABlock(restLength);
        //判斷新的存儲(chǔ)塊是否創(chuàng)建成功
        Debug.Assert(m_ChunkLength == 0, "A new block was not created.");
        // 將value中未放入到m_ChunkChars的剩余部放入擴(kuò)容后的m_ChunkChars中去
        new ReadOnlySpan<char>(value + firstLength, restLength).CopyTo(m_ChunkChars);
        // 更新當(dāng)前已使用長(zhǎng)度
        m_ChunkLength = restLength;
    }
    //一些針對(duì)當(dāng)前StringBuilder的校驗(yàn)操作,和相關(guān)邏輯無關(guān)不做詳細(xì)介紹
    //類似的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已存儲(chǔ)的長(zhǎng)度=塊的偏移量+當(dāng)前塊使用的長(zhǎng)度
    get => m_ChunkOffset + m_ChunkLength;
    set
    {
        //注意這里是有代碼的只是我們暫時(shí)省略set邏輯
    }
}

//當(dāng)前StringBuilder實(shí)際存儲(chǔ)的總長(zhǎng)度
public int Length
{
    //StringBuilder已存儲(chǔ)的長(zhǎng)度=塊的偏移量+當(dāng)前塊使用的長(zhǎng)度
    get => m_ChunkOffset + m_ChunkLength;
    set
    {
        //注意這里是有代碼的只是我們暫時(shí)省略set邏輯
    }
}
//當(dāng)前StringBuilder的總?cè)萘?
public int Capacity
{
    get => m_ChunkChars.Length + m_ChunkOffset;
    set
    {
        //注意這里是有代碼的只是我們暫時(shí)省略set邏輯
    }
}

//可承載字符的最大容量,即可以拼接的字符串的長(zhǎng)度
internal int m_MaxCapacity;
//承載【拼接字符串的char數(shù)組
internal char[] m_ChunkChars;
//當(dāng)前塊的最大長(zhǎng)度
internal const int MaxChunkSize = 8000;
//當(dāng)前m_ChunkChars字符數(shù)組中已經(jīng)使用的長(zhǎng)度
internal int m_ChunkLength;
//存儲(chǔ)塊的偏移量,用于計(jì)算總長(zhǎng)度
internal int m_ChunkOffset;
//前一個(gè)存儲(chǔ)塊
internal StringBuilder? m_ChunkPrevious;
private void ExpandByABlock(int minBlockCharCount)
{
    //當(dāng)前塊m_ChunkChars存儲(chǔ)滿才進(jìn)行擴(kuò)容操作
    Debug.Assert(Capacity == Length, nameof(ExpandByABlock) + " should only be called when there is no space left.");
    //minBlockCharCount指的是剩下的需要存儲(chǔ)的長(zhǎng)度
    Debug.Assert(minBlockCharCount > 0);
    AssertInvariants();

    //StringBuilder的總長(zhǎng)度不能大于StringBuilder的m_MaxCapacity
    if ((minBlockCharCount + Length) > m_MaxCapacity || minBlockCharCount + Length < minBlockCharCount)
    {
        throw new ArgumentOutOfRangeException();
    }

    //!!!需要擴(kuò)容塊的新長(zhǎng)度=max(當(dāng)前追加字符的剩余長(zhǎng)度,min(當(dāng)前StringBuilder長(zhǎng)度,8000))
    int newBlockLength = Math.Max(minBlockCharCount, Math.Min(Length, MaxChunkSize));

    //判斷長(zhǎng)度是否越界
    if (m_ChunkOffset + m_ChunkLength + newBlockLength < newBlockLength)
    {
        throw new OutOfMemoryException();
    }

    // 申請(qǐng)一個(gè)新的存塊長(zhǎng)度為newBlockLength
    char[] chunkChars = GC.AllocateUninitializedArray<char>(newBlockLength);

    //!!!把當(dāng)前StringBuilder中的存儲(chǔ)塊存放到一個(gè)新的StringBuilder實(shí)例中，當(dāng)前實(shí)例的m_ChunkPrevious指向上一個(gè)StringBuilder
    //這里可以看出來擴(kuò)容的本質(zhì)是構(gòu)建節(jié)點(diǎn)為StringBuilder的鏈表
    m_ChunkPrevious = new StringBuilder(this);
    //偏移量是每次擴(kuò)容的時(shí)候去修改,它的長(zhǎng)度就是記錄了已使用塊的長(zhǎng)度,但是不包含當(dāng)前StringBuilder的存儲(chǔ)塊
    //可以理解為偏移量=長(zhǎng)度-已經(jīng)存放擴(kuò)容塊的長(zhǎng)度
    m_ChunkOffset += m_ChunkLength;
    //因?yàn)橐呀?jīng)擴(kuò)容了新的容器所以重置已使用長(zhǎng)度
    m_ChunkLength = 0;
    //把新的塊重新賦值給當(dāng)前存儲(chǔ)塊m_ChunkChars數(shù)組
    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();
}

//當(dāng)前StringBuilder實(shí)際存儲(chǔ)的總長(zhǎng)度
public int Length
{
    //StringBuilder已存儲(chǔ)的長(zhǎng)度=塊的偏移量+當(dāng)前塊使用的長(zhǎng)度
    get => m_ChunkOffset + m_ChunkLength;
    set
    {
        //注意這里是有代碼的只是我們暫時(shí)省略set邏輯
    }
}
public override string ToString()
{
    AssertInvariants();
    //當(dāng)前StringBuilder長(zhǎng)度為0則直接返回空字符串
    if (Length == 0)
    {
        return string.Empty;
    }
    //FastAllocateString函數(shù)負(fù)責(zé)分配長(zhǎng)度為StringBuilder長(zhǎng)度的字符串
    //這個(gè)字符串就是ToString最終返回的結(jié)果,所以長(zhǎng)度等于StringBuilder的長(zhǎng)度
    string result = string.FastAllocateString(Length);
    //當(dāng)前StringBuilder是遍歷的第一個(gè)鏈表節(jié)點(diǎn)
    StringBuilder? chunk = this;
    do
    {
        //當(dāng)前使用長(zhǎng)度必須大于0，也就是說當(dāng)前塊的m_ChunkChars必須使用過,才需要遍歷當(dāng)前節(jié)點(diǎn)
        if (chunk.m_ChunkLength > 0)
        {
            // 取出當(dāng)前遍歷的StringBuilder的相關(guān)數(shù)據(jù)
            // 當(dāng)前遍歷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();
            }
            //把當(dāng)前遍歷項(xiàng)StringBuilder的m_ChunkChars逐步添加到result中當(dāng)前結(jié)果的前端
            Buffer.Memmove(
                ref Unsafe.Add(ref result.GetRawStringData(), chunkOffset),
                ref MemoryMarshal.GetArrayDataReference(sourceArray),
                (nuint)chunkLength);
        }
        //獲取當(dāng)前StringBuilder的前一個(gè)節(jié)點(diǎn),循環(huán)遍歷鏈表操作
        chunk = chunk.m_ChunkPrevious;
    }
    //如果m_ChunkPrevious==null則代表是第一個(gè)節(jié)點(diǎn)
    while (chunk != null);

    return result;
}

//初始化一個(gè)等于StringBuilder長(zhǎng)度的字符串
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我的祖國(guó)一刻也不能分割,無論我走到哪里都留下一首贊歌。";
//第三次遍歷后
result = "我和我的祖國(guó)一刻也不能分割,無論我走到哪里都留下一首贊歌。";

//存儲(chǔ)塊也就是承載Append數(shù)據(jù)的容器
char[] value;
//StringBuilder的總長(zhǎng)度
int count;
public StringBuilder() {
    //默認(rèn)的容量也是16
    super(16);
}

public StringBuilder(String str) {
    //這個(gè)地方有差異如果通過指定字符串初始化StringBuilder
    //則初始化的長(zhǎng)度則是當(dāng)前傳遞的str的長(zhǎng)度+16
    super(str.length() + 16);
    append(str);
}

// AbstractStringBuilder.java
AbstractStringBuilder(int capacity) {
    value = new char[capacity];
}

// AbstractStringBuilder.java
public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    // 這里是擴(kuò)容操作
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    //每次append之后重新設(shè)置長(zhǎng)度
    count += len;
    return this;
} 

private void ensureCapacityInternal(int minimumCapacity) {
    //當(dāng)前需要的長(zhǎng)度>char[]的長(zhǎng)度則需要擴(kuò)容
    if (minimumCapacity - value.length > 0)
        expandCapacity(minimumCapacity);
}

void expandCapacity(int minimumCapacity) {
    //新擴(kuò)容的長(zhǎng)度是當(dāng)前塊char[]的長(zhǎng)度的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;
    }
    //把當(dāng)前的char[]復(fù)制到新擴(kuò)容的字符數(shù)組中
    value = Arrays.copyOf(value, newCapacity);
}

// Arrays.java copy的邏輯
public static char[] copyOf(char[] original, int newLength) {
    //聲明一個(gè)新的數(shù)組，把original的數(shù)據(jù)copy到新的char數(shù)組中
    char[] copy = new char[newLength];
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

@Override
public String toString() {
    // 這里創(chuàng)建了一個(gè)新的String對(duì)象返回，通過當(dāng)前char[]初始化這個(gè)字符串
    return new String(value, 0, count);
}