Quando usar StringBuilder?

Question

Eu entendo os benefícios do StringBuilder.

Mas se eu quiser concatenar 2 cordas, então eu suponho que é melhor (mais rápido) para fazê-lo sem StringBuilder. É este correto?

Em que ponto (número de cordas) é que se torna melhor usar StringBuilder?

Answer 1

I calorosamente sugiro que você leia O triste tragédia de Micro-Otimização Teatro , por Jeff Atwood.

Trata simples concatenação versus StringBuilder vs. outros métodos.

Agora, se você quiser ver alguns números e gráficos, siga o link;)

Answer 2

Mas se eu quiser concatenar 2 cordas, então eu assumir que é melhor (mais rápido) para fazê-lo sem StringBuilder. É este correto?

Isso é realmente correta, você pode encontrar exatamente por isso que explicou muito bem em:

http://www.yoda.arachsys.com/csharp/stringbuilder.html

Resumiu: se você pode concatenar cordas de uma só vez como

var result = a + " " + b  + " " + c + ..

Você está melhor sem StringBuilder apenas na cópia é feita (o comprimento da cadeia resultante é calculada de antemão.);

Para a estrutura como

var result = a;
result  += " ";
result  += b;
result  += " ";
result  += c;
..

novos objetos são criados a cada vez, por isso não deve considerar StringBuilder.

No final o artigo resume essas regras de ouro:

regras de ouro

Assim, quando você deve usar StringBuilder, e quando você deve usar a string operadores de concatenação?

• Definitivamente usar StringBuilder quando você está concatenando em um não-trivial loop - especialmente se você não sabe com certeza (em tempo de compilação) quantas iterações você vai fazer através do ciclo. Por exemplo, a leitura de um arquivo de um carácter de cada vez, construindo um string como você vai usar o operador + = é potencialmente suicida desempenho.

• Definitivamente usar a concatenação operador quando você pode (legível) especificar tudo o que precisa ser concatenados em um comunicado. (Se vocês têm uma série de coisas para concatenate, considerar chamar String.Concat explicitamente - ou String.Join se você precisar de um delimitador.)

• Não tenha medo de quebrar literais-se em vários bits concatenados - o resultado será o mesmo. Você pode ajudar legibilidade, quebrando um longo literal em várias linhas, por exemplo, com nenhum dano ao desempenho.

• Se você precisa os resultados intermediários da concatenação de algo outro que não a alimentação da próxima iteração de concatenação, StringBuilder não é vai ajudá-lo. Por exemplo, se você construir um nome completo de um primeiro nome e um sobrenome, e, em seguida, adicionar um terceira peça de informação (o apelido, talvez) até o fim, você vai só beneficiam de usar StringBuilder se você não precisa do (primeiro nome + sobrenome) string para outra finalidade (Como fazemos no exemplo que cria uma pessoa objeto).

• Se você só tem alguns concatenations para fazer, e você realmente deseja fazê-las em declarações separadas, isso não acontece realmente importa que caminho você vai. Qual maneira é mais eficiente dependerá o número de concatenações os tamanhos de corda envolvidos, e que ordem eles estão concatenadas. Se você realmente Acredito que parte do código a ser um gargalo de desempenho, perfil ou referência as duas coisas.

Answer 3

System.String é um objeto imutável - isso significa que sempre que você modificar seu conteúdo que irá alocar uma nova seqüência e isso leva tempo (e memória?). Usando StringBuilder você modificar o conteúdo real do objeto sem alocar um novo.

Assim, o uso StringBuilder quando você precisa fazer muitas modificações na cadeia.

Answer 4

Nem por isso ... você deve usar StringBuilder se você concatenar grande cordas ou você tem muitos concatenações, como em um loop.

Answer 5

Não há uma resposta definitiva, somente regras de polegar. Minhas próprias regras pessoais mais ou menos assim:

• Se concatenação em um loop, use sempre um StringBuilder.
• Se as cordas são grandes, use sempre um StringBuilder.
• Se o código de concatenação é arrumado e legível na tela, em seguida, é provavelmente ok.
  Se não for, use um StringBuilder.

Answer 6

Para paráfrase

Então te contar até três, nem mais, nem menos. Três será o número tu contagem, e o número da contagem deve ser de três. Quatro ás tu não contar, não conte tu dois, com exceção de que tu então proceder a três. Uma vez que o número três, sendo o terceiro número, ser alcançado, então lobbest o teu Santo Granada de mão de Antioquia

Eu geralmente uso construtor corda para qualquer bloco de código que resultaria na concatenação de três ou mais strings.

Answer 7

• Se você concatenar strings em um loop, você deve considerar usar StringBuilder em vez de seqüência regular
• Em caso é único concatenação, você não pode ver a diferença em tempo de execução em todos

Aqui é um aplicativo simples teste para provar o ponto:

class Program
{
    static void Main(string[] args)
    {
        const int testLength = 30000;
        var StartTime = DateTime.Now;

        //TEST 1 - String
        StartTime = DateTime.Now;
        String tString = "test string";
        for (int i = 0; i < testLength; i++)
        {
            tString += i.ToString();
        }
        Console.WriteLine((DateTime.Now - StartTime).TotalMilliseconds.ToString());
        //result: 2000 ms

        //TEST 2 - StringBuilder
        StartTime = DateTime.Now;
        StringBuilder tSB = new StringBuilder("test string");
        for (int i = 0; i < testLength; i++)
        {
            tSB.Append(i.ToString());
        }
        Console.WriteLine((DateTime.Now - StartTime).TotalMilliseconds.ToString());
        //result: 4 ms

        Console.ReadLine();
    }
}

Resultados:

• 30'000 iterações

  • String - 2000 ms
  • StringBuilder - 4 ms

• 1000 iterações

  • String - 2 ms
  • StringBuilder - 1 ms

• 500 iterações

  • String - 0 ms
  • StringBuilder - 0 ms

Answer 8

Mas se eu quiser concatenar 2 cordas, então eu suponho que é melhor e mais rápido para fazê-lo sem StringBuilder. É este correto?

Sim. Mas o mais importante, é muito mais legível para usar um String baunilha em tais situações. Usá-lo em um loop, por outro lado, faz sentido e também pode ser tão legível como concatenação.

Eu seria cauteloso em regras de ouro que Citam números específicos de concatenação como um limite. Usá-lo em loops (e apenas voltas) é provavelmente tão útil, fácil de lembrar e faz mais sentido.

Answer 9

Enquanto você pode digitar fisicamente o número de encadeamentos (a + b + c ...) ele não deve fazer uma grande diferença. N ao quadrado (em N = 10) é uma desaceleração 100X, o que não deve ser muito ruim.

O grande problema é quando você está concatenando centenas de cordas. No N = 100, você recebe um vezes desaceleração 10000x. Que é muito ruim.

Answer 10

Eu não acho que há uma linha tênue entre quando usar ou quando não. A menos é claro que alguém realizou alguns testes extensivos para sair com as condições de ouro.

Para mim, eu não vou usar StringBuilder se apenas concatenando 2 enormes cordas. Se há loop com uma contagem undeterministic, estou provável que, mesmo que o loop pode ser pequeno, conta.

Answer 11

A única concatenação não vale a pena usar um StringBuilder. Eu normalmente usado 5 concatenations como uma regra de ouro.

Answer 12

O StringBuilder classe fornece ao desenvolvedor um conjunto de métodos que permite a manipulação de uma corda mutável de caracteres, ele pode ser usado quando você deseja modificar uma string sem criar um novo objeto, eliminando assim a sobrecarga ou gargalo questão da concatenação seqüência normal.

Usando o StringBuilder classe pode melhorar o desempenho quando concatenando muitas cordas juntos em um loop.

A seguir está uma lista de algumas operações que podem ser realizadas para manipular uma string usando a classe StringBuilder em .NET

Anexar :. Anexa informações ao final do StringBuilder atual

AppendFormat :. Substitui um especificador de formato passado em uma string com texto formatado

Inserir :. Insere uma string ou objeto no índice especificado do StringBuilder atual

Remover :. Remove um número especificado de caracteres do StringBuilder atual

Substitua :. Substitui um caractere especificado em um índice especificado