StringBuilder: ¿cómo obtener el String final?

Question

Alguien me dijo que es más rápido concatenar cadenas con StringBuilder. He cambiado mi código pero no veo ninguna de las propiedades o métodos para obtener la cadena de compilación final.

¿Cómo puedo obtener la cadena?

Answer 1

Puedes usar .ToString () para obtener String del StringBuilder .

Answer 2

Cuando dices " es más rápido concatenar String con un generador de String " ;, esto solo es cierto si eres repetidamente (repito - repetidamente ) concatenando a la mismo objeto.

Si solo está concatenando 2 cadenas y haciendo algo con el resultado inmediatamente como una cadena , no tiene sentido usar StringBuilder .

Me topé con el buen artículo de Jon Skeet: http: // www. yoda.arachsys.com/csharp/stringbuilder.html

Si está utilizando StringBuilder , para obtener la cadena resultante, solo tiene que llamar a ToString () (no es sorprendente).

Answer 3

Una vez que haya completado el procesamiento con StringBuilder, use el método ToString para devolver el resultado final.

Desde 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

Me gustaría deshacerme de eso, lo cual no necesariamente es más rápido, definitivamente tendrá una mejor huella de memoria. Esto se debe a que las cadenas son inmutables en .NET y cada vez que cambias una cadena, creas una nueva.

Answer 5

Acerca de que sea más rápido / mejor memoria:

Analicé este problema con Java, asumo que .NET sería muy inteligente al respecto.

La implementación de String es bastante impresionante.

El objeto String rastrea " longitud " y " compartido " (independientemente de la longitud de la matriz que contiene la cadena)

Así que algo como

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

se puede implementar (por el compilador / tiempo de ejecución) 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.

Debido a que la mayoría de las cadenas son de corta duración, en muchos casos esto es un código MUY eficiente. El caso en el que es absolutamente NO eficiente es cuando se agrega a una cadena dentro de un bucle, o cuando su código es así:

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

En este caso, es mucho mejor usar una construcción StringBuilder.

Mi punto es que debes tener cuidado cuando optimices, a menos que estés absolutamente seguro de que sabes lo que estás haciendo, Y estás absolutamente seguro de que es necesario, Y realizas una prueba para asegurarte de que el código optimizado haga pasar un caso de uso. simplemente codifíquelo de la forma más legible posible y no intente dejar de pensar el compilador.

Perdí 3 días jugando con cadenas, almacenando en caché / reutilizando los constructores de cadenas y probando la velocidad antes de mirar el código fuente de la cadena y darme cuenta de que el compilador ya lo estaba haciendo mejor de lo que podía para mi caso de uso. Luego tuve que explicar que REALMENTE no sabía lo que estaba haciendo, solo pensé que sí ...

Answer 6

No es más rápido concentrarse: como señala smaclell, el problema es la cadena inmutable que fuerza una asignación adicional y la copia de datos existentes.

" a " + " b " + " c " no es más rápido que hacer con el generador de cadenas, pero concats repetidos con una cadena intermedia se vuelve más y más rápido a medida que el número de concat se hace más grande como:

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