C# StringBuilder
Strings in C# are immutable — once created, they cannot be changed. Every time you modify a string, C# creates an entirely new string object in memory. For programs that build or modify text repeatedly, this wastes memory and slows performance. StringBuilder solves this problem.
The Problem with Regular Strings
Imagine building a sentence by joining 1,000 words one at a time using the + operator. Each addition creates a brand new string, throws away the old one, and copies everything again.
┌──────────────────────────────────────────────────────────────┐ │ STRING CONCATENATION — MEMORY PROBLEM │ ├──────────────────────────────────────────────────────────────┤ │ │ │ Step 1: "Hello" → 1 object in memory │ │ Step 2: "Hello" + " World" → 2nd object created │ │ old "Hello" discarded │ │ Step 3: "Hello World" + "!" → 3rd object created │ │ old "Hello World" discarded │ │ Step 4: (repeat 1,000 times) → 1,000 wasted objects │ │ │ └──────────────────────────────────────────────────────────────┘
The solution is StringBuilder, which modifies text in a single block of memory without creating new objects every time.
What Is StringBuilder?
StringBuilder is a class in the System.Text namespace. It acts like a whiteboard — you can write, erase, and rewrite text on the same surface without getting a new board every time.
┌──────────────────────────────────────────────────────────────┐ │ STRINGBUILDER — SINGLE BUFFER │ ├──────────────────────────────────────────────────────────────┤ │ │ │ Buffer: [ H | e | l | l | o | | | | | ] │ │ │ │ Append " World": │ │ Buffer: [ H | e | l | l | o | | W | o | r | l | d ] │ │ │ │ Same object in memory — no copying — just extending │ │ │ └──────────────────────────────────────────────────────────────┘
Creating a StringBuilder
Add the namespace first, then create the object.
using System;
using System.Text; // Required for StringBuilder
StringBuilder sb = new StringBuilder();
sb.Append("Hello");
sb.Append(" World");
Console.WriteLine(sb.ToString()); // Hello World
You can also initialize it with starting text and a capacity:
StringBuilder sb = new StringBuilder("Start:", 100);
// "Start:" is the initial text
// 100 is the initial buffer capacity (optional hint)
Common StringBuilder Methods
Append()
Adds text to the end of the current content.
StringBuilder sb = new StringBuilder();
sb.Append("Name: ");
sb.Append("Alice");
Console.WriteLine(sb.ToString()); // Name: Alice
AppendLine()
Adds text followed by a new line. Equivalent to adding \n at the end.
StringBuilder sb = new StringBuilder();
sb.AppendLine("Line 1");
sb.AppendLine("Line 2");
sb.AppendLine("Line 3");
Console.Write(sb.ToString());
// Output:
// Line 1
// Line 2
// Line 3
Insert()
Inserts text at a specific position.
StringBuilder sb = new StringBuilder("Hello World");
sb.Insert(5, ","); // Insert comma at index 5
Console.WriteLine(sb.ToString()); // Hello, World
// Diagram:
// Before: H e l l o W o r l d
// 0 1 2 3 4 5 6 7 8 9 10
//
// After Insert at 5: H e l l o , W o r l d
Remove()
Deletes a section of text starting at a given index for a given length.
StringBuilder sb = new StringBuilder("Hello, World!");
sb.Remove(5, 2); // Remove 2 characters starting at index 5
Console.WriteLine(sb.ToString()); // HelloWorld!
Replace()
Replaces all occurrences of one text with another — in place.
StringBuilder sb = new StringBuilder("I like cats and cats");
sb.Replace("cats", "dogs");
Console.WriteLine(sb.ToString()); // I like dogs and dogs
Clear()
Removes all content from the StringBuilder, resetting it to empty.
StringBuilder sb = new StringBuilder("Some text");
sb.Clear();
Console.WriteLine(sb.Length); // 0
Length and Capacity
StringBuilder sb = new StringBuilder("Hello");
Console.WriteLine(sb.Length); // 5 (current character count)
Console.WriteLine(sb.Capacity); // 16 (default initial buffer size)
sb.Append(" World");
Console.WriteLine(sb.Length); // 11
Length vs Capacity Diagram
┌────────────────────────────────────────────────────────────┐ │ Length = actual characters stored │ │ Capacity = total buffer space available │ ├────────────────────────────────────────────────────────────┤ │ │ │ Buffer (capacity 16): │ │ [ H | e | l | l | o |___|___|___|___|___|___|___|___|___] │ │ ←─── Length = 5 ───→ ←──── unused space (11 slots) ────→ │ │ │ └────────────────────────────────────────────────────────────┘
Converting StringBuilder to String
A StringBuilder is not a string. To use it as a string (for display, storage, or comparison), call ToString().
StringBuilder sb = new StringBuilder();
sb.Append("C#");
sb.Append(" is great");
string result = sb.ToString();
Console.WriteLine(result); // C# is great
Performance Comparison
┌─────────────────────────────┬──────────────────────────────┐ │ Regular String (+) │ StringBuilder │ ├─────────────────────────────┼──────────────────────────────┤ │ Creates new object each │ Modifies same object │ │ time you concatenate │ in memory │ ├─────────────────────────────┼──────────────────────────────┤ │ Slow for many operations │ Fast for many operations │ ├─────────────────────────────┼──────────────────────────────┤ │ Simple, readable │ Slightly more code │ ├─────────────────────────────┼──────────────────────────────┤ │ Best for 0–10 joins │ Best for 10+ joins in a loop │ └─────────────────────────────┴──────────────────────────────┘
Real Scenario: Building an HTML Table Row
using System;
using System.Text;
StringBuilder html = new StringBuilder();
string[] products = { "Apple", "Banana", "Cherry" };
html.AppendLine("<table>");
foreach (string product in products)
{
html.AppendLine("<tr><td>" + product + "</td></tr>");
}
html.AppendLine("</table>");
Console.WriteLine(html.ToString());
Using StringBuilder here is efficient because the loop runs multiple times. Using regular string concatenation in loops is one of the most common C# performance mistakes beginners make.
When to Use StringBuilder
Use StringBuilder when: ✅ You build strings in a loop ✅ You append text more than 10 times ✅ You process large amounts of text ✅ Performance matters in string operations Use regular strings when: ✅ You do a small number of joins (2-3 times) ✅ You need simple, readable one-line operations ✅ You compare or check strings
StringBuilder is one of the most practical performance tools in C#. Knowing when to use it separates programmers who write working code from programmers who write fast, professional code.