Prueba de eficiencia: StringBuilder vs. Concatenación de Strings

Ya os comentábamos en el artículo sobre el StringBuilder, que éste ofrecía una notable mejora de eficiencia a la hora de concatenar strings, pero para quitarle la abstracción a la expresión "notable mejora de eficiencia", hemos realizado una prueba de eficiencia.

Ésta es muy sencilla:

eficiencia.cs
       // Prueba 1
       //int Nsb = 5000;
       //int Nstring = 5000;

       // Prueba 2
       //int Nsb = 50000;
       //int Nsb = 50000;

       // Prueba 3
       int Nsb = 10000000;
       int Nsb = 100000;

        // Con StringBuilder
        DateTime inicio = DateTime.Now;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < Nsb ; i++)
        {
            sb.Append(i);
        }
        DateTime final = DateTime.Now;
        TimeSpan duracionA = final - inicio;

        // Con strings
        inicio = DateTime.Now;
        string txt = string.Empty;
        for (int i = 0; i < Nstring ; i++)
        {
            txt += i;
        }
        final = DateTime.Now;
        TimeSpan duracionB = final - inicio;


Como veis la prueba se ha hecho cambiando los valores a mano, podíamos haber preparado algo que nos devolviera un gráfico con estadísticas, etc., pero los resultados son tan esclarecedores que no hace falta . Además, tampoco se ha hecho una media con resultados, etc. Simplemente queremos mostrar el orden de magnitud de diferencia.

Escenario de la prueba:
- AMD 2200+, 1 Gb RAM
- VWD Express
- Muchos otros programas ejecutándose

Resultado Prueba 1 (Nsb = 5.000, Nstring = 5.000)
duracion A = 0
duracion B = 0,21875
Conclusión: aún pidiendo un bajo rendimiento, el string ya necesita 2 décimas que pueden llegar a ser muy valiosas, mientras que el StringBuilder ni se inmuta.

Resultado Prueba 2 (Nsb = 50.000, Nstring = 50.000)
duracion A = 0,046875
duracion B = 70,5625
Conclusión: Cuando comenzamos a pedir un rendimiento más serio, la concatenación con strings crece exponencialmente (más de un minuto!!), mientras que el StringBuilder no llega ni a cinco centésimas. Eso son 3 órdenes de magnitud!!

Resultado Prueba 3 (Nsb = 10.000.000, Nstring = 100.000)
duracion A = 8,9375
duracion B = 212,421875
Conclusión: nos hemos querido poner serios y le hemos pedido al stingBuilder dos órdenes de magnitud más que a la concatencación con strings (10 millones vs 100 mil), y aún así el resultado sigue siendo abrumador para el StringBuilder, ganándole en dos órdenes de magnitud.


Explicación
Internamente, para concatenar un string, lo que se hace es crear una nueva instancia de string, copiar el string actual en esa nueva instancia y borrar la instancia original, que es lo que en el ámbito de la ingeniería avanzada suele llamarse "el cuento de la vieja"

Consejo
Siempre que podáis, aunque sea para las operaciones más simples, utilizad el StringBuilder frente a la concatención de strings... y si es para operaciones más costosas ni os lo penséis!