StringBuilder: como obter o final String?

Question

Alguém me disse que é mais rápido para cordas concatenar com StringBuilder. Eu mudei meu código, mas eu não vejo qualquer propriedades ou métodos para obter a seqüência de construção final.

Como posso obter a string?

Answer 1

Você pode usar .ToString() para obter o String do StringBuilder.

Answer 2

Quando você diz "é mais rápido para String concatenar com um construtor de String", isto só é verdade se você é repetidamente (repito - repetidamente ) concatenando ao mesmo objeto.

Se você está apenas concatenando 2 cordas e fazer algo com o resultado imediatamente como um string, não há nenhum ponto de usar StringBuilder.

Eu só tropeçou em bom gravação de Jon Skeet-se disto: http: // www. yoda.arachsys.com/csharp/stringbuilder.html

Se você estiver usando StringBuilder, em seguida, para obter o string resultante, é apenas uma questão de chamar ToString() (sem surpresa).

Answer 3

Depois de ter concluído o processamento usando o StringBuilder, use o método ToString para retornar o resultado final.

De MSDN:

using System;
using System.Text;

public sealed class App 
{
    static void Main() 
    {
        // Create a StringBuilder that expects to hold 50 characters.
        // Initialize the StringBuilder with "ABC".
        StringBuilder sb = new StringBuilder("ABC", 50);

        // Append three characters (D, E, and F) to the end of the StringBuilder.
        sb.Append(new char[] { 'D', 'E', 'F' });

        // Append a format string to the end of the StringBuilder.
        sb.AppendFormat("GHI{0}{1}", 'J', 'k');

        // Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString());

        // Insert a string at the beginning of the StringBuilder.
        sb.Insert(0, "Alphabet: ");

        // Replace all lowercase k's with uppercase K's.
        sb.Replace('k', 'K');

        // Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString());
    }
}

// This code produces the following output.
//
// 11 chars: ABCDEFGHIJk
// 21 chars: Alphabet: ABCDEFGHIJK

Answer 4

Eu gostaria apenas de jogar fora que é pode não ser necessariamente mais rápido, ela vai definitivamente ter um melhor consumo de memória. Isso ocorre porque cordas são imutáveis ??em .NET e cada vez que você alterar uma string de ter criado um novo.

Answer 5

Sobre ele ser mais rápido / melhor memória:

Eu olhei para esta questão com Java, presumo .NET seria tão esperto sobre isso.

A implementação para String é bastante impressionante.

As objeto String faixas "comprimento" e "compartilhada" (independente do comprimento da matriz que detém a string)

Então, algo como

String a = "abc" + "def" + "ghi";

pode ser implementada (pelo compilador / runtime) como:

 - Extend the array holding "abc" by 6 additional spaces.
 - Copy def in right after abc 
 - copy ghi in after def. 
 - give a pointer to the "abc" string to a 
 - leave abc's length at 3, set a's length to 9
 - set the shared flag in both.

Uma vez que a maioria das cordas são de curta duração, isto faz algum código muito eficiente em muitos casos. O caso em que é absolutamente NÃO eficiente é quando você está adicionando a uma corda dentro de um loop, ou quando o código é assim:

a = "abc";
a = a + "def";
a += "ghi";

Neste caso, você é muito melhor fora de usar uma construção StringBuilder.

Meu ponto é que você deve ter cuidado sempre que você otimizar, a menos que você esteja absolutamente certo de que você sabe o que está fazendo, e você tem certeza absoluta de que é necessário, e você testar para garantir o código otimizado faz uma passagem caso de uso, código apenas isso da forma mais legível possível e não tente out-acho que o compilador.

Eu perdi 3 dias mexendo com cordas, cache / reutilização de cordas de construtores e teste de velocidade antes de eu olhei para o código-fonte de cordas e descobri que o compilador já estava fazendo isso melhor do que eu poderia possivelmente para o meu caso de uso. Então eu tive que explicar como eu realmente não sabia o que eu estava fazendo, eu só pensei que eu fiz ...

Answer 6

Não mais rápida é a concat -. Como smaclell fora pontas, a questão é a seqüência imutável forçando uma atribuição extra e recopying dos dados existentes

"a" + "b" + "c" não mais rápido é fazer com construtor corda, mas concats repetido com uma cadeia intermediária fica mais rápido e mais rápido como o # de concat de fica maior como:

x = "a"; x + = "b"; x = + "C"; ...