How stringbuilder append work - stringbuffer

Question

How many objects will be created by below code and please explain how?
StringBuilder s=new StringBuilder();
s.append("hi"+"java"+"test");

Answer 1

So from the msdn docs at the bottom of the page:
The following example illustrates how a StringBuilder object allocates
new memory and increases its capacity dynamically as the string
assigned to the object expands. The code creates a StringBuilder
object by calling its default (parameterless) constructor. The default
capacity of this object is 16 characters, and its maximum capacity is
more than 2 billion characters. Appending the string "This is a
sentence." results in a new memory allocation because the string
length (19 characters) exceeds the default capacity of the
StringBuilder object. The capacity of the object doubles to 32
characters, the new string is added, and the length of the object now
equals 19 characters. The code then appends the string "This is an
additional sentence." to the value of the StringBuilder object 11
times. Whenever the append operation causes the length of the
StringBuilder object to exceed its capacity, its existing capacity is
doubled and the Append operation succeeds.
I highlighted in bold the important parts.
So basically, the steps are:
StringBuilder creates a length to hold some strings
when the length is surpassed it will double it until it can hold the strings
Looking at line 373 in the source to output the string it will read through the memory addresses putting it together... from a very high level.
So thing to remember that it doesnt create objects, it's just dynamic reallocation of memory space to handle the new length of strings determined when append is called.
To Answer your question further
Scenario A), we set a length:
var s = new StringBuilder(10);
s.Append("hijavatest");
This should create a string builder of capacity 10, and store that string in it.
Scenario B), we don't specify a length:
var s = new StringBuilder();
s.Append("hi");
s.Append("java");
s.Append("test");
This will create the default capacity of a string builder: 16. and shouldn't change size to append all the new strings.
Scenario C), we set a small length:
var s = new StringBuilder(3);
s.Append("hi");
s.Append("java"); // doubles capacity to 6
s.Append("test"); // doubles capacity to 12
This will double the capacity till it can store all the string, in this case 12.
Run the below code in dotnetfiddle:
using System;
using System.Text;
public class Program
{
public static void Main()
{
ScenarioA();
ScenarioB();
ScenarioC();
}
private static void ShowSBInfo(StringBuilder sb)
{
foreach (var prop in sb.GetType().GetProperties()) {
if (prop.GetIndexParameters().Length == 0)
Console.Write("{0}: {1:N0} ", prop.Name, prop.GetValue(sb));
}
Console.WriteLine();
}
private static void ScenarioA()
{
Console.WriteLine("Scenario A");
var sb = new StringBuilder(10);
ShowSBInfo(sb);
sb.Append("hijavatest");
ShowSBInfo(sb);
}
private static void ScenarioB()
{
Console.WriteLine("Scenario B");
var sb = new StringBuilder();
ShowSBInfo(sb);
sb.Append("hi");
ShowSBInfo(sb);
sb.Append("java");
ShowSBInfo(sb);
sb.Append("test");
ShowSBInfo(sb);
}
private static void ScenarioC()
{
Console.WriteLine("Scenario C");
var sb = new StringBuilder(3);
ShowSBInfo(sb);
sb.Append("hi");
ShowSBInfo(sb);
sb.Append("java"); // doubles capacity to 6
ShowSBInfo(sb);
sb.Append("test"); // doubles capacity to 12
ShowSBInfo(sb);
}
}