When should you use StringBuilder instead of string concatenation in C#? How does StringBuilder work internally, and what are the alternatives such as string.Join, string.Create and interpolation?

1. StringBuilder internals (since .NET Framework 4)

public sealed class StringBuilder
{
    internal char[] m_ChunkChars;          // this chunk's buffer
    internal StringBuilder? m_ChunkPrevious; // linked list of previous chunks
    internal int m_ChunkLength;            // used chars in this chunk
    internal int m_ChunkOffset;            // total chars in previous chunks
    internal int m_MaxCapacity;
}

The StringBuilder object you hold is the last chunk; earlier chunks are linked backwards. Appending to the end is O(1) amortised; when the current chunk fills, a new chunk is allocated with size max(minBlockSize, min(totalLength, 8000)), and the old state is moved into a "previous" node. Chunks are capped at 8,000 chars so no chunk lands on the Large Object Heap.

Trade-offs of the chunk design:

• Append never copies existing data — great for building.
• Insert, Remove, Replace and the indexer sb[i] are slower, because they may need to walk the chunk list (indexing from the start is O(chunks)). Iterating sb[i] in a loop over a large builder is accidentally quadratic. Use GetChunks() (.NET Core 3.0+) to enumerate ReadOnlyMemory<char> chunks efficiently.
• ToString() allocates a string of exact length and copies each chunk.

2. Amortised analysis

With geometric growth, the total number of characters allocated across all chunks is at most ~2× the final length, and each character is copied exactly twice: once on Append, once in ToString(). Compare with +=: character k is copied n − k times.

3. Interpolated string handlers (C# 10)

string s = $"{name} owes {amount:C}";

is lowered to:

var h = new DefaultInterpolatedStringHandler(literalLength: 6, formattedCount: 2);
h.AppendFormatted(name);
h.AppendLiteral(" owes ");
h.AppendFormatted(amount, "C");
string s = h.ToStringAndClear();

• The handler starts with a stack buffer or an ArrayPool<char> rental.
• AppendFormatted<T>(T value) is generic, so value types are not boxed; if T implements ISpanFormattable, it formats straight into the buffer.
• StringBuilder.Append(ref AppendInterpolatedStringHandler) uses the same idea to write into the builder directly.
• You can pass a stack buffer explicitly: string.Create(CultureInfo.InvariantCulture, stackalloc char[64], $"...").

4. string.Create

public static string MaskCard(string pan) =>
    string.Create(pan.Length, pan, static (span, src) =>
    {
        span.Fill('*');
        src.AsSpan(src.Length - 4).CopyTo(span[^4..]);
    });

The runtime allocates the string once and gives you a writable Span<char> over its memory before it is published, so you can fill it without any intermediate buffer. The static lambda plus state argument avoids closure allocation. This is what high-performance BCL code (e.g. Guid.ToString, Convert.ToHexString) does internally.

5. string.Join and string.Concat

string.Join(separator, IEnumerable<string>) has special paths: for arrays and lists it computes the total length in one pass and copies once; for arbitrary enumerables it uses a ValueStringBuilder internally. string.Concat(ReadOnlySpan<string?>) (.NET 9 params ReadOnlySpan) avoids allocating an array for the arguments.

6. Pooling builders

Allocating a new StringBuilder per request is usually fine. In very hot paths you can pool:

private static readonly ObjectPool<StringBuilder> Pool =
    new DefaultObjectPoolProvider().CreateStringBuilderPool(initialCapacity: 256, maximumRetainedCapacity: 4096);

var sb = Pool.Get();
try { /* build */ return sb.ToString(); }
finally { Pool.Return(sb); }

The maximumRetainedCapacity stops a single huge builder from being kept in the pool forever.

7. When not to build strings at all

For HTTP responses, files and exports, write to the destination incrementally:

await using var writer = new StreamWriter(response.Body, Encoding.UTF8, bufferSize: 16 * 1024);
foreach (var row in rows)
{
    await writer.WriteLineAsync($"{row.Id},{row.Total.ToString(CultureInfo.InvariantCulture)}");
}

Memory stays constant regardless of row count, and the client starts receiving data sooner.

Try it yourself

1. Benchmark +=, StringBuilder (with and without capacity), string.Join and string.Create for 10, 1,000 and 100,000 items with [MemoryDiagnoser].
2. Index into a large StringBuilder with sb[i] in a loop and compare with GetChunks().
3. Paste an interpolated string into SharpLab and read the generated handler code.
4. Implement MaskCard with string.Create and measure allocations.

using System.Text;
using Microsoft.Extensions.ObjectPool;

namespace Strings;

public sealed record OrderLine(string Sku, int Qty, decimal Price);

public static class Builders
{
    private static readonly ObjectPool<StringBuilder> Pool =
        new DefaultObjectPoolProvider().CreateStringBuilderPool();

    // Loop with unknown size: StringBuilder with an estimated capacity
    public static string RenderLines(IReadOnlyList<OrderLine> lines)
    {
        var sb = new StringBuilder(capacity: lines.Count * 32);
        foreach (var line in lines)
        {
            sb.Append($"{line.Sku},{line.Qty},{line.Price:F2}").AppendLine(); // handler: no temp string
        }
        return sb.ToString();
    }

    // Hot path: reuse builders from a pool
    public static string RenderPooled(IReadOnlyList<OrderLine> lines)
    {
        var sb = Pool.Get();
        try
        {
            sb.AppendJoin('|', lines.Select(l => l.Sku));
            return sb.ToString();
        }
        finally
        {
            Pool.Return(sb);   // policy clears it
        }
    }

    // Fixed number of parts: plain interpolation is best
    public static string Label(OrderLine l) => $"{l.Sku} x{l.Qty}";

    // Known length: string.Create writes once
    public static string OrderId(int number) => string.Create(10, number, static (span, n) =>
    {
        span.Fill('0');
        Span<char> digits = stackalloc char[10];
        n.TryFormat(digits, out int written);
        digits[..written].CopyTo(span[^written..]);
    });

    public static void Main()
    {
        var lines = new List<OrderLine> { new("A1", 2, 9.5m), new("B2", 1, 120m) };
        Console.Write(RenderLines(lines));
        Console.WriteLine(RenderPooled(lines));
        Console.WriteLine(Label(lines[0]));
        Console.WriteLine(OrderId(4521));   // 0000004521
    }
}