Qual método de concatenação de string a ser usado para n número de iterações?

Question

Se eu quiser concatenar uma string n número de vezes, qual método devo preferir?

Pegue este código como exemplo:

public static string Repeat(this string instance, int times)
{
        var result = string.Empty;

        for (int i = 0; i < times; i++)
            result += instance;

        return result;
}

Este método pode ser chamado com "Times" definido para 5 ou 5000. Qual método devo preferir usar?

String.Join? Stringbuilder? Apenas Standard String.Concat?

Uma função semelhante será implementada em uma biblioteca comercial, então eu realmente preciso da maneira "ideal" de fazer isso.

Answer 1

    public static string Repeat(this string instance, int times)
    {
        if (times == 1 || string.IsNullOrEmpty(instance)) return instance;
        if (times == 0) return "";
        if (times < 0) throw new ArgumentOutOfRangeException("times");
        StringBuilder sb = new StringBuilder(instance.Length * times);
        for (int i = 0; i < times; i++)
            sb.Append(instance);
        return sb.ToString();
    }

Answer 2

Stringbuilder of Claro. Ele se destina a operações de junção de string rápida, porque não criará um novo objeto cada vez que você deseja entrar em uma string.

Para detalhes, consulte aqui.

Answer 3

StringBuilder.

"Result += resultado;"

Cria uma nova string toda vez que você faz a atribuição e atribui essa nova string à sua variável, pois as strings são imutáveis.

Vá com Stringbuilder, definitivamente.

Answer 4

Nunca assuma que um método seja mais rápido que outro - você deve medir o desempenho de ambos e depois decidir.

Surpreendentemente, para um número menor de iterações, apenas uma concatenação de string padrão (resultado += string) é frequentemente mais rápida do que usar um construtor de string.

Se você souber que o número de iterações sempre será o mesmo (por exemplo, sempre serão 50 iterações), sugiro que você faça algumas medidas de desempenho usando métodos diferentes.

Se você verdade Deseja ficar inteligente, fazer medições de desempenho em relação ao número de iterações e você pode encontrar o 'ponto de cruzamento' em que um método é mais rápido que outro e o código rígido que limia ao método:

if(iterations < 30)
{
    CopyWithConcatenation();
}
else
{
    CopyWithStringBuilder();
}

O ponto de crossover de desempenho exato dependerá dos detalhes específicos do seu código e você nunca poderá descobrir o que são sem fazer medições de desempenho.

Para complicar um pouco mais as coisas, o StringBuilder tem gerenciamento de memória 'mais antigo' que a String Concatenation (que cria mais instâncias temporárias), portanto, isso também pode ter um impacto no desempenho geral fora do seu loop de string (como na próxima vez que o coletor de lixo executar).

Deixe -nos saber como você se saiu.