C>>>Не стоит выставлять на показ свои проблемы с логикой.

ГВ>>String s = strBuilder.ToString(); // Отдал строку
ГВ>>strBuilder.Append("ABC"); // Вернул себе копию того, что было отдано через ToString и продолжил модификацию
ГВ>>

const int Count = 1000000;
String str = "Text";

StringBuilder sb = new StringBuilder();
for(int i = 0; i < 10; ++i)
sb.Append("0123456789");
String s;

Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < Count; i++)
{
    s = sb.ToString();
}
stopwatch.Stop();
Console.WriteLine("Elapsed 1 {0}", stopwatch.Elapsed);

stopwatch.Reset();
stopwatch.Start();
for (int i = 0; i < Count; i++)
{
    s = sb.ToString();
    s = sb.ToString();
    s = sb.ToString();
    s = sb.ToString();
    s = sb.ToString();
}
stopwatch.Stop();
Console.WriteLine("Elapsed 5 {0}", stopwatch.Elapsed);

ГВ>Как это, не будет копирования строки?

public override string ToString()
{
    string stringValue = this.m_StringValue;
    .....................................
    stringValue.ClearPostNullChar();// добиваем пространство за Length + 1 нулями
    this.m_currentThread = IntPtr.Zero; // устанавливаем флаг на то что есть ссылка на строку
    return stringValue; // возвращаем ссылку на внутреннюю строку
}

public StringBuilder Append(string value)
{
    if (value != null)
    {
        string stringValue = this.m_StringValue;
        IntPtr currentThread = Thread.InternalGetCurrentThread();
        if (this.m_currentThread != currentThread) // Вот здесь если m_currentThread == IntPtr.Zero
        {                                          // Выделяется новая строка
            stringValue = string.GetStringForStringBuilder(stringValue, stringValue.Capacity);
        }
        int length = stringValue.Length;
        int requiredLength = length + value.Length;
        if (this.NeedsAllocation(stringValue, requiredLength))
        {// если места нехватает выделяется новая строка с новым капасити currentString.Capacity * 2;
            string newString = this.GetNewString(stringValue, requiredLength);
            newString.AppendInPlace(value, length);
            this.ReplaceString(currentThread, newString); 
        }
        else
        {
            stringValue.AppendInPlace(value, length);
            this.ReplaceString(currentThread, stringValue); // зписывается вместо старой
        }
    }
    return this;
}

this.m_currentThread = IntPtr.Zero;

public override string ToString()
{
    string stringValue = this.m_StringValue;
    if (this.m_currentThread != Thread.InternalGetCurrentThread()) // Вот здесь если IntPtr.Zero идет копирование строки
    {                                                              
        return string.InternalCopy(stringValue);
    }
    if ((2 * stringValue.Length) < stringValue.ArrayLength)
    {
        return string.InternalCopy(stringValue);
    }
    stringValue.ClearPostNullChar();
    this.m_currentThread = IntPtr.Zero;
    return stringValue;
}

WF>Я не делаю предположений, я смотрю рефлектором. Но там не всё так прозрачно. Судя по коду, есть подозрение, что только первый .ToString не вызовет копирования.

// Viva паранойя: разогрев StringBuilder:
for (int k = 0; k < 5; ++k)
{
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < 2; ++i)
        sb.Append("0123456789");
    String s = sb.ToString();
}

// Тест
const int Count = 10000000;
const int ConcatCount = 1;
const String StrConcat = "0123456789";
Stopwatch stopwatch = new Stopwatch();


stopwatch.Start();
for (int k = 0; k < Count; ++k)
{
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < ConcatCount; ++i)
        sb.Append(StrConcat);
    String s = "A";
}
stopwatch.Stop();
TimeSpan tsCreate = stopwatch.Elapsed;
Console.WriteLine("Elapsed creation {0}", stopwatch.Elapsed);

stopwatch.Reset();
stopwatch.Start();
for (int k = 0; k < Count; ++k)
{
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < ConcatCount; ++i)
        sb.Append(StrConcat);
    String s = sb.ToString();
}
stopwatch.Stop();
TimeSpan tsCreateAssign = stopwatch.Elapsed;
Console.WriteLine("Elapsed create+assign {0}", stopwatch.Elapsed);

stopwatch.Reset();
stopwatch.Start();
for (int k = 0; k < Count; ++k)
{
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < ConcatCount; ++i)
        sb.Append(StrConcat);
    String s = sb.ToString();
    s = sb.ToString();
}
stopwatch.Stop();
TimeSpan tsCreateAssign2 = stopwatch.Elapsed;
Console.WriteLine("Elapsed create+assign2 {0}", stopwatch.Elapsed);

Console.WriteLine("EC:ECA ~=~ 1:{0}", tsCreateAssign.TotalMilliseconds / tsCreate.TotalMilliseconds);
Console.WriteLine("ECA:ECA2 ~=~ 1:{0}", tsCreateAssign2.TotalMilliseconds / tsCreate.TotalMilliseconds);

double dCAC = tsCreateAssign.TotalMilliseconds - tsCreate.TotalMilliseconds;
double dCA2CA = tsCreateAssign2.TotalMilliseconds - tsCreateAssign.TotalMilliseconds;

Console.WriteLine("ECA-EC = {0} ms (D1)", dCAC / Count);
Console.WriteLine("ECA2-ECA = {0} ms (D2)", dCA2CA / Count);
Console.WriteLine("D2:D1 = {0}:1", dCA2CA / dCAC);

Console.WriteLine("EC:ECA ~=~ 1:{0}", tsCreateAssign.TotalMilliseconds / tsCreate.TotalMilliseconds);
Console.WriteLine("ECA:ECA2 ~=~ 1:{0}", tsCreateAssign2.TotalMilliseconds / tsCreateAssign.TotalMilliseconds);

S>this.m_currentThread = IntPtr.Zero; 
S>

public override string ToString()
{
    /*
      this.m_currentThread - маркер "нахожусь в процессе модификации".
    */
    string stringValue = this.m_StringValue;
    if (this.m_currentThread != Thread.InternalGetCurrentThread()) // Вот здесь если IntPtr.Zero идет копирование строки
    {
      /*
        Это происходит в потоке, "чужом" по отношению к тому, который сейчас модифицирует строку.
        Другой случай - никто ничего не модифицирует, просто висит буфер с какими-то оставшимися данными.
      */
        return string.InternalCopy(stringValue);
    }
    if ((2 * stringValue.Length) < stringValue.ArrayLength)
    {
      /*
        А вот это - в том потоке, который сейчас занят модификацией.
        Если буфер заполнен меньше, чем на половину, то копируем строку.
        Маркер "продолжающейся модификации" при этом не снимается.
      */
        return string.InternalCopy(stringValue);
    }

    /*
      Если буфер заполнен больше, чем на половину, имеется активная модификация, и всё это происходит в потоке,
      осуществляющем эту модификацию, то считаем, что этим вызовом ToString текущая модификация заканчивается.
      Вот такая эвристика.
    */

    stringValue.ClearPostNullChar();
    this.m_currentThread = IntPtr.Zero;
    return stringValue;
}