Classe StringBuilder para trabalhar com strings

1. Introdução

Só pra lembrar, strings em C# são imutáveis (immutable). Isso quer dizer que, depois de criar, você não consegue mudar a string: qualquer operação que parece "mudar" a string, na real cria uma nova string na memória.

Por exemplo, quando você escreve:

string hello = "Privet";
hello += " mir!"; // Parece que hello mudou, mas na real foi criado um novo objeto!

A variável hello aponta pra um novo objeto, e o antigo (se não for usado em nenhum lugar) vai ser apagado pelo garbage collector uma hora dessas. Se você faz esse tipo de coisa num loop várias vezes, pode rolar um "acúmulo" na memória RAM e o desempenho despenca. Isso fica ainda mais tenso se você junta milhares ou milhões de strings: a cada passo, uma string nova é criada, todos os caracteres são copiados, os objetos antigos ficam lá até o garbage collector passar, e seu programa começa a travar do nada.

É aí que entra o herói dessa aula — StringBuilder.

using System.Text; // ← obrigatório!
StringBuilder sb = new StringBuilder("Privet");
sb.Append(" mir!"); // Agora a string muda rapidinho e de boa

Conhecendo o StringBuilder

StringBuilder é uma classe do namespace System.Text. O objetivo dela é montar e juntar strings grandes de forma eficiente, mudando o conteúdo sem ficar criando objeto novo toda hora.

Analogia:
Se uma string (string) é tipo um pedaço de mosaico que só dá pra trocar inteiro, o StringBuilder é tipo um quadro magnético onde você pode colar e tirar os pedacinhos quantas vezes quiser, sem precisar de um quadro novo toda vez que quiser mexer no mosaico.

Quando vale a pena usar StringBuilder?

• Se você muda a string várias vezes (principalmente em loop).
• Se tá montando um texto a partir de vários pedacinhos pequenos.
• Se você se importa com velocidade e uso de memória.

Quando NÃO vale a pena usar?

• Se você só vai fazer 1 ou 2 operações simples com a string — o string normal é mais fácil e legível.
• Se você realmente quer (por algum motivo) guardar cada estado diferente da string.

2. Criando e usando o StringBuilder

Importando o namespace

Pra começar, é só importar o namespace.

using System.Text;// ← obrigatório!

Jeitos de criar uma nova string

StringBuilder sb1 = new StringBuilder();            // Vazio
StringBuilder sb2 = new StringBuilder("Start");     // Com texto inicial
StringBuilder sb3 = new StringBuilder(100);         // Com espaço pra 100 caracteres

Métodos principais

var sb = new StringBuilder("Inicio");
sb.Append(" + adicionei novo texto"); 			// Adiciona no final
sb.AppendLine(" (e esse com quebra de linha)"); 	// Adiciona com \n
sb.Insert(0, "Start: "); 						// Insere na posição 0
sb.Remove(0, 7); 								// Remove 7 caracteres a partir do 0
sb.Replace("texto", "STRING"); 					// Troca todo "texto" por "STRING"
string result = sb.ToString(); 					// Pega a string final

3. Eficiência do StringBuilder

Exemplo: comparando desempenho

Imagina que você precisa montar uma string com 10 000 números seguidos (sei lá, te pediram pra mostrar todos os números dos seus colegas de turma):

Jeito ingênuo (string)

string text = "";
for (int i = 0; i < 10000; i++)
{
    text += i + " "; // Em cada passo cria uma string nova!
}
Console.WriteLine(text.Substring(0, 100) + "..."); // Só pra não imprimir tudo

Jeito otimizado (StringBuilder)

var sb = new StringBuilder();
for (int i = 0; i < 10000; i++)
{
    sb.Append(i).Append(' '); // Dá pra encadear!
}
Console.WriteLine(sb.ToString().Substring(0, 100) + "...");

Qual a diferença?
O primeiro jeito vai rodar bem mais devagar e pode "comer" muito mais memória. O segundo é rápido e não pesa na RAM.

4. Métodos mais usados do StringBuilder

Append — adiciona uma string ou outro tipo (converte pra string automaticamente):

sb.Append("texto");
sb.Append(123); // 123 vira "123"
sb.Append('!'); // Caractere

AppendLine — adiciona uma string + quebra de linha:

sb.AppendLine("linha"); // Adiciona "linha\n"

Insert — insere uma string numa posição específica:

sb.Insert(0, "Hello, "); // Insere no começo

Remove — remove alguns caracteres:

sb.Remove(3, 4); // Remove 4 caracteres a partir do 3

Replace — troca todas as ocorrências de uma substring ou caractere:

sb.Replace("old", "new");
sb.Replace('a', 'A');

ToString — retorna a string pronta.

Cortando a string

Diferente do string, um objeto StringBuilder pode ter o tamanho mudado direto. Assim, a string é cortada até esse tamanho.

sb.Length = 10; // Tudo depois do 10º caractere some!

5. Particularidades e erros comuns

Por que ToString() é importante

Enquanto você tá mexendo com o StringBuilder, você não tem uma string na mão, mas sim um objeto especial. Muitos métodos (tipo Console.WriteLine) aceitam ele de boa, porque ele sabe se transformar em string automaticamente, mas às vezes você pode se surpreender — tipo se comparar com uma string normal ou fizer algo assim:

if (sb == "Privet") { ... } // Opa! Isso não vai funcionar, mesmo se sb tiver "Privet"

O resultado vai ser false: você tá comparando objetos de tipos diferentes, não strings.

O certo é:

if (sb.ToString() == "Privet") { ... }

Mutabilidade

Diferente do string, o StringBuilder é mutável (mutable)! Um objeto só pode mudar o conteúdo quantas vezes quiser, e é isso que deixa ele rápido.

Não esquece do ToString() no final do trabalho com o objeto, senão você vai pegar um texto estranho tipo System.Text.StringBuilder.

Tamanho do buffer e realocação

Por dentro, o StringBuilder guarda um array de caracteres. Se você já sabe que vai "montar" uma string bem grande, pode passar o tamanho esperado no construtor — isso deixa tudo um pouco mais rápido.

var bigBuilder = new StringBuilder(50000); // Esperando 50 mil caracteres

Mas se você errar — relaxa! O StringBuilder aumenta o buffer sozinho se precisar, só vai ficar um pouco mais lento.

Estourar a memória?

Teoricamente, se você exagerar e adicionar bilhões de caracteres, pode acabar caindo num OutOfMemoryException, mas pra tarefas normais isso quase nunca acontece.