¿La forma más eficiente de concatenar cadenas?

¿Cuál es la forma más eficiente de concatenar cadenas?

El StringBuilder.Append()método es mucho mejor que usar el +operador. Pero he descubierto que, al ejecutar 1000 concatenaciones o menos, String.Join()es aún más eficiente que StringBuilder.

StringBuilder sb = new StringBuilder();
sb.Append(someString);

El único problema con String.Joines que tienes que concatenar las cadenas con un delimitador común.

Editar: como señaló @ryanversaw , puede hacer el delimitador string.Empty.

string key = String.Join("_", new String[] 
{ "Customers_Contacts", customerID, database, SessionID });

Rico Mariani , el gurú de .NET Performance, tenía un artículo sobre este mismo tema. No es tan simple como uno podría sospechar. El consejo básico es este:

Si su patrón se ve así:

x = f1(...) + f2(...) + f3(...) + f4(...)

ese es un concat y es rápido, StringBuilder probablemente no ayudará.

Si su patrón se ve así:

if (...) x += f1(...)
if (...) x += f2(...)
if (...) x += f3(...)
if (...) x += f4(...)

entonces probablemente quieras StringBuilder.

Otro artículo para respaldar esta afirmación proviene de Eric Lippert, donde describe las optimizaciones realizadas en +concatenaciones de una línea de manera detallada.

Hay 6 tipos de concatenaciones de cadenas:

1. Usando el +símbolo más ( ).
2. Utilizando string.Concat().
3. Utilizando string.Join().
4. Utilizando string.Format().
5. Utilizando string.Append().
6. Utilizando StringBuilder.

En un experimento, se ha demostrado que string.Concat()es la mejor manera de acercarse si las palabras son menos de 1000 (aproximadamente) y si las palabras son más de 1000, entonces StringBuilderdeben usarse.

Para obtener más información, consulte este sitio .

string.Join () vs string.Concat ()

El método string.Concat aquí es equivalente a la invocación del método string.Join con un separador vacío. Agregar una cadena vacía es rápido, pero no hacerlo es aún más rápido, por lo que el método string.Concat sería superior aquí.

De Chinh Do: StringBuilder no siempre es más rápido :

Reglas de juego

• Cuando concatene tres valores de cadena dinámica o menos, use la concatenación de cadena tradicional.

• Cuando concatene más de tres valores de cadena dinámica, use StringBuilder.

• Cuando construya una cadena grande a partir de varios literales de cadena, use el @literal de cadena o el operador en línea +.

La mayoría de las veces StringBuilderes su mejor apuesta, pero hay casos, como se muestra en esa publicación, que al menos debería pensar en cada situación.

Si está operando en un bucle, StringBuilderes probablemente el camino a seguir; le ahorra la sobrecarga de crear nuevas cadenas regularmente. Sin embargo, en el código que solo se ejecutará una vez, String.Concatprobablemente esté bien.

Sin embargo, Rico Mariani (gurú de la optimización .NET) realizó un cuestionario en el que afirmó al final que, en la mayoría de los casos, recomienda String.Format.

Este es el método más rápido que he desarrollado durante una década para mi aplicación NLP a gran escala. Tengo variaciones para IEnumerable<T>y otros tipos de entrada, con y sin separadores de diferentes tipos ( Char, String), pero aquí muestro el caso simple de concatenar todas las cadenas en una matriz en una sola cadena, sin separador. La última versión aquí está desarrollada y probada en C # 7 y .NET 4.7 .

Hay dos claves para un mayor rendimiento; el primero es calcular previamente el tamaño total exacto requerido. Este paso es trivial cuando la entrada es una matriz como se muestra aquí. En IEnumerable<T>cambio, para el manejo , vale la pena reunir primero las cadenas en una matriz temporal para calcular ese total (la matriz se requiere para evitar llamar ToString()más de una vez por elemento, ya que técnicamente, dada la posibilidad de efectos secundarios, hacerlo podría cambiar la semántica esperada de una operación de 'unión de cadenas').

A continuación, dado el tamaño total de asignación de la cadena final, el mayor impulso en el rendimiento se obtiene al construir la cadena de resultados en el lugar . Hacer esto requiere la técnica (quizás controvertida) de suspender temporalmente la inmutabilidad de un nuevo Stringque inicialmente se asigna lleno de ceros. Dejando a un lado cualquier controversia, sin embargo ...

... tenga en cuenta que esta es la única solución de concatenación masiva en esta página que evita por completo una ronda adicional de asignación y copia por parte del Stringconstructor.

Código completo:

/// <summary>
/// Concatenate the strings in 'rg', none of which may be null, into a single String.
/// </summary>
public static unsafe String StringJoin(this String[] rg)
{
    int i;
    if (rg == null || (i = rg.Length) == 0)
        return String.Empty;

    if (i == 1)
        return rg[0];

    String s, t;
    int cch = 0;
    do
        cch += rg[--i].Length;
    while (i > 0);
    if (cch == 0)
        return String.Empty;

    i = rg.Length;
    fixed (Char* _p = (s = new String(default(Char), cch)))
    {
        Char* pDst = _p + cch;
        do
            if ((t = rg[--i]).Length > 0)
                fixed (Char* pSrc = t)
                    memcpy(pDst -= t.Length, pSrc, (UIntPtr)(t.Length << 1));
        while (pDst > _p);
    }
    return s;
}

[DllImport("MSVCR120_CLR0400", CallingConvention = CallingConvention.Cdecl)]
static extern unsafe void* memcpy(void* dest, void* src, UIntPtr cb);

Debo mencionar que este código tiene una ligera modificación de lo que yo uso. En el original, llamo a la instrucción cpblk IL de C # para hacer la copia real. Por simplicidad y portabilidad en el código aquí, reemplacé eso con P / Invoke memcpy, como puede ver. Para obtener el máximo rendimiento en x64 ( pero quizás no en x86 ), puede utilizar el método cpblk .

De este artículo de MSDN :

Hay algunos gastos generales asociados con la creación de un objeto StringBuilder, tanto en tiempo como en memoria. En una máquina con memoria rápida, un StringBuilder vale la pena si está realizando unas cinco operaciones. Como regla general, diría que 10 o más operaciones de cadena es una justificación para la sobrecarga en cualquier máquina, incluso una más lenta.

Entonces, si confía en MSDN, vaya con StringBuilder si tiene que hacer más de 10 operaciones / concatenaciones de cadenas; de lo contrario, la cadena simple concat con '+' está bien.

También es importante señalar que debe usar el +operador si está concatenando literales de cadena .

Cuando concatena literales de cadena o constantes de cadena usando el operador +, el compilador crea una sola cadena. No se produce concatenación de tiempo de ejecución.

Cómo: Concatenar cadenas múltiples (Guía de programación de C #)

Además de las otras respuestas, tenga en cuenta que StringBuilder puede recibir una cantidad inicial de memoria para asignar .

El parámetro de capacidad define el número máximo de caracteres que se pueden almacenar en la memoria asignada por la instancia actual. Su valor se asigna a la propiedad Capacidad . Si el número de caracteres que se almacenarán en la instancia actual excede este valor de capacidad , el objeto StringBuilder asigna memoria adicional para almacenarlos.

Si la capacidad es cero, se utiliza la capacidad predeterminada específica de la implementación.

Agregar repetidamente a un StringBuilder que no ha sido preasignado puede resultar en muchas asignaciones innecesarias al igual que concatenar repetidamente cadenas regulares.

Si sabe cuánto durará la cadena final, puede calcularla trivialmente o puede hacer una suposición educada sobre el caso común (asignar demasiado no es necesariamente algo malo), debe proporcionar esta información al constructor o al Capacidad de propiedad. Especialmente cuando se ejecutan pruebas de rendimiento para comparar StringBuilder con otros métodos como String.Concat, que hacen lo mismo internamente. Cualquier prueba que vea en línea que no incluya la asignación previa de StringBuilder en sus comparaciones es incorrecta.

Si no puede adivinar el tamaño, probablemente esté escribiendo una función de utilidad que debería tener su propio argumento opcional para controlar la preasignación.

Lo siguiente puede ser una solución alternativa más para concatenar múltiples cadenas.

String str1 = "sometext";
string str2 = "some other text";

string afterConcate = $"{str1}{str2}";

interpolación de cuerdas

Lo más eficiente es usar StringBuilder, así:

StringBuilder sb = new StringBuilder();
sb.Append("string1");
sb.Append("string2");
...etc...
String strResult = sb.ToString();

@jonezy: String.Concat está bien si tienes un par de cosas pequeñas. Pero si está concatenando megabytes de datos, es probable que su programa se acumule.

Pruebe estas 2 piezas de código y encontrará la solución.

 static void Main(string[] args)
    {
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < 10000000; i++)
        {
            s.Append( i.ToString());
        }
        Console.Write("End");
        Console.Read();
    }

Vs

static void Main(string[] args)
    {
        string s = "";
        for (int i = 0; i < 10000000; i++)
        {
            s += i.ToString();
        }
        Console.Write("End");
        Console.Read();
    }

Encontrará que el primer código terminará realmente rápido y la memoria estará en una buena cantidad.

El segundo código tal vez la memoria estará bien, pero llevará más tiempo ... mucho más. Entonces, si tiene una aplicación para muchos usuarios y necesita velocidad, use la 1ra. Si tiene una aplicación para un usuario a corto plazo, tal vez pueda usar ambas o la segunda será más "natural" para los desarrolladores.

Salud.

Para solo dos cadenas, definitivamente no desea usar StringBuilder. Hay un umbral por encima del cual la sobrecarga de StringBuilder es menor que la sobrecarga de asignar varias cadenas.

Entonces, para más de 2-3 cadenas, use el código de DannySmurf . De lo contrario, solo use el operador +.

System.String es inmutable. Cuando modificamos el valor de una variable de cadena, se asigna una nueva memoria al nuevo valor y se libera la asignación de memoria anterior. System.StringBuilder fue diseñado para tener el concepto de una cadena mutable donde se pueden realizar una variedad de operaciones sin asignación de ubicación de memoria separada para la cadena modificada.

Otra solución:

dentro del bucle, use List en lugar de string.

List<string> lst= new List<string>();

for(int i=0; i<100000; i++){
    ...........
    lst.Add(...);
}
return String.Join("", lst.ToArray());;

Es muy muy rápido.

Realmente depende de su patrón de uso. Un punto de referencia detallado entre string.Join, string, Concat y string.Format se puede encontrar aquí: String.Format no es adecuado para el registro intensivo

(Esta es en realidad la misma respuesta que le di a esta pregunta)

Dependería del código. StringBuilder es más eficiente en general, pero si solo concatena unas pocas cadenas y lo hace todo en una línea, las optimizaciones de código probablemente se encargarán de usted. También es importante pensar en cómo se ve el código: para conjuntos más grandes StringBuilder facilitará la lectura, para los pequeños StringBuilder simplemente agregará desorden innecesario.