Por que usar StringBuilder?

Outro dia fiz um post que mostra a comparação entre String e StringBuilder com relação a velocidade de execução. A intuito deste novo post é explicar o por que do StringBuilder levar muito menos tempo na execução do que os Strings comuns. [Dica do 1000TON - Valeu cara!]

O que o Milton disse no comentário dele foi:

Realmente a diferença é brutal. A forma de trabalho das strings faz com que a mesma seja mais lerda, isso pq sempre que concatenamos o compilador gera um novo array de char com o tamanho final (antigo + tamanho concatenado)

…..

Vamos as explicações

Toda vez que o conteúdo de uma string é alterado, um novo objeto string é criado na memória, o que requer uma nova alocação de espaço para esse novo objeto. Em situações onde é necessários realizar repetidas modificações em uma string (como o caso do exemplo que dei no meu post), a sobrecarga associada à criação de um novo string pode ter um custo caro, tanto em tempo de execução, quanto em uso de memória. O StringBuilder pode ser usado para esses casos de necessidade de modificar strings sem criar um novo objeto.

O StringBuilder representa uma sequência de caracteres cujo valor pode ser modificado. Dizer que o valor pode ser modificado significa que pode ser alterado depois de ter sido criado, acrescentando, removendo ou substituindo caracters.

O desempenho de uma operação de concatenação de um String ou StringBuilder depende da freqüência na qual a alocação de memória ocorre. Como já disse, um string sempre aloca memória a cada concatenação (alteração). Já com o StringBuilder, a operação de concatenação aloca memória apenas para os novos conteúdos adicionados. Consequentemente, string é preferível para operações de concatenação com um número fixo de objetos a serem concatenados. Nesse caso, as operações de concatenação são combinadas em uma única operação pelo compilador.  Já o StringBuilder é preferível para uma operação de concatenação quando um número grande de concatenações devem ser realizadas.

Membros importantes do StringBuilder

• Construtor StringBuilder(): Inicializa uma nova instância da classe StringBuilder.
• Método Append(): Concatena um novo objeto à instância do StringBuilder. Existem vários overloads deste métodos, na qual vários tipos de dados podem ser usados, como Boolean, Int, Decimal, String, etc., não necessariamente strings.
• Método AppendLine(): Concatena um novo objeto à instância do StringBuilder e adiciona um terminador de linha ao final da concatenação.
• Método Clear(): Limpa o StringBuilder.
• Método Insert(): Insere o conteúdo especificado na posição desejada.
• Método Remove(): Remove o intervalo especificado de caracteres da instância do StringBuilder.
• Método Replace(): Substitui todas as ocorrências de um caractere especificado com outro caractere especificado.
• Método ToString(): Converte o conteúdo do StringBuilder para uma string comum.
• Propriedade Capacity: Obtém ou define a quantidade máxima de caracteres que podem ser contidos na memória alocada pela instância do StringBuilder.
• Propriedade Length: Obtém o comprimento da instância atual do StringBuilder.

Fontes

• Using the StringBuilder Class
• System.Text.StringBuilder

String Vs. StringBuilder

Você concatena strings com concatenação comum ou usa o StringBuilder?

Há alguns dias fui questionado sobre isso e na hora me veio a idéia de fazer um teste para comparação.

Conceitos

StringBuilder: http://msdn.microsoft.com/en-us/library/2839d5h5(v=VS.100).aspx

String: http://msdn.microsoft.com/en-us/library/362314fe(v=VS.100).aspx

Vamos ao Teste

Fiz um pequeno programa que simula uma grande quantidade de concatenações ou appends em StringBuilders. A idéia é um bloco for que concatena uma string várias vezes e outro bloco for que faz vários appends em um StringBuilder. Algo desse tipo:

// Várias concatenações na string
string str = string.Empty;
for (int i = 1; i <= qt; i++)
    str = str + " Concatenação nº " + i.ToString();

// Vários appends no StringBuilder
StringBuilder stb = new StringBuilder();
for (int i = 1; i <= qt; i++)
{
    stb.Append(" Append nº ");
    stb.Append(i.ToString());
}

O resultado foi de impressionar. Veja:

No teste, executei 100.000 concatenações/appends, e o tempo de execução das concatenações foi absurdamente maior que o tempo de execução dos appends.

Portanto, a partir de agora, use StringBuilder em vez de strings comuns.

O código fonte pode ser baixado aqui.

Valeu galera!