Stringbuilder does not create new instance if the initial capacity set too small but a book says otherwise

StringBuilder sb = new StringBuilder("test", 4);
sb.Append('\n');
sb.AppendLine("test1");
sb.AppendLine("test2");
sb.AppendLine("test3");
sb.AppendLine("test4");

looking on IL code there is only one newobj line, but I thought there should be more instances of StringBuilder class since it should increase its capacity by creating new object? Or I got it wrong?

// [3 1 - 3 49]
    IL_0000: ldstr        "test"
    IL_0005: ldc.i4.4
    IL_0006: newobj       instance void [System.Runtime]System.Text.StringBuilder::.ctor(string, int32)
    IL_000b: stloc.0      // sb

    // [4 1 - 4 17]
    IL_000c: ldloc.0      // sb
    IL_000d: ldc.i4.s     10 // 0x0a
    IL_000f: callvirt     instance class [System.Runtime]System.Text.StringBuilder [System.Runtime]System.Text.StringBuilder::Append(char)
    IL_0014: pop

    // [5 1 - 5 24]
    IL_0015: ldloc.0      // sb
    IL_0016: ldstr        "test1"
    IL_001b: callvirt     instance class [System.Runtime]System.Text.StringBuilder [System.Runtime]System.Text.StringBuilder::AppendLine(string)
    IL_0020: pop

    // [6 1 - 6 24]
    IL_0021: ldloc.0      // sb
    IL_0022: ldstr        "test2"
    IL_0027: callvirt     instance class [System.Runtime]System.Text.StringBuilder [System.Runtime]System.Text.StringBuilder::AppendLine(string)
    IL_002c: pop

    // [7 1 - 7 24]
    IL_002d: ldloc.0      // sb
    IL_002e: ldstr        "test3"
    IL_0033: callvirt     instance class [System.Runtime]System.Text.StringBuilder [System.Runtime]System.Text.StringBuilder::AppendLine(string)
    IL_0038: pop

    // [8 1 - 8 24]
    IL_0039: ldloc.0      // sb
    IL_003a: ldstr        "test4"
    IL_003f: callvirt     instance class [System.Runtime]System.Text.StringBuilder [System.Runtime]System.Text.StringBuilder::AppendLine(string)
    IL_0044: pop
    IL_0045: ret

from Troelsen book about c#, translated paragraph by me: "If you add more characters than the specified limit, the StringBuilder object will copy its data to a new instance and increase the buffer size by the specified limit."

Asked a friend to provide original quote, here it is, page 89 "Pro C#10 with .Net 6":

> If you append more characters than the specified limit, the
> StringBuilder object will copy its data into a new instance and grow
> the buffer by the specified limit.

Looking at your own C# code's IL will not tell you anything about what StringBuilder does internally, which is what the book is talking about. You would need to look at StringBuilder's source code, or its IL to see that.

The documentation of StringBuilder only mentions "new buffers" or "allocating new memory", and never specifically "new instances of StringBuilder".

> New data is appended to the buffer if room is available; otherwise, a new, larger buffer is allocated, data from the original buffer is copied to the new buffer, and the new data is then appended to the new buffer.

> If the number of added characters causes the length of the StringBuilder object to exceed its current capacity, new memory is allocated, the value of the Capacity property is doubled, new characters are added to the StringBuilder object, and its Length property is adjusted.

So whether or not it creates new instances of StringBuilders is an implementation detail. Looking at source.dot.net, it does indeed do that in ExpandByABlock.

// Allocate the array before updating any state to avoid leaving inconsistent state behind in case of out of memory exception
char[] chunkChars = GC.AllocateUninitializedArray<char>(newBlockLength);

// Move all of the data from this chunk to a new one, via a few O(1) reference adjustments.
// Then, have this chunk point to the new one as its predecessor.
m_ChunkPrevious = new StringBuilder(this);
m_ChunkOffset += m_ChunkLength;
m_ChunkLength = 0;

m_ChunkChars = chunkChars;

In this implementation, StringBuilder is implemented as a linked list. The StringBuilder instances are nodes. The above code basically sets the previous node to a copy of this, and make this an "empty" node with a capacity of newBlockLength.