Le moyen le plus efficace de concaténer des chaînes?

Quelle est la manière la plus efficace de concaténer des chaînes?

La StringBuilder.Append()méthode est bien meilleure que l'utilisation de l' +opérateur. Mais j'ai trouvé que, lors de l'exécution de 1000 concaténations ou moins, String.Join()c'est encore plus efficace que StringBuilder.

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

Le seul problème avec String.Joinest que vous devez concaténer les chaînes avec un délimiteur commun.

Edit: comme l' a souligné @ryanversaw , vous pouvez faire le délimiteur string.Empty.

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

Rico Mariani , le gourou de la performance .NET, avait un article sur ce même sujet. Ce n'est pas aussi simple qu'on pourrait le penser. Le conseil de base est le suivant:

Si votre motif ressemble à:

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

c'est un concat et c'est zippy, StringBuilder n'aidera probablement pas.

Si votre motif ressemble à:

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

alors vous voulez probablement StringBuilder.

Un autre article à l'appui de cette affirmation vient d'Eric Lippert où il décrit de +manière détaillée les optimisations effectuées sur des concaténations sur une ligne .

Il existe 6 types de concaténations de chaînes:

1. Utilisation du +symbole plus ( ).
2. Utilisation string.Concat().
3. Utilisation string.Join().
4. Utilisation string.Format().
5. Utilisation string.Append().
6. Utilisation StringBuilder.

Dans une expérience, il a été prouvé que string.Concat()c'est la meilleure façon d'approcher si les mots sont inférieurs à 1000 (approximativement) et si les mots sont supérieurs à 1000 alors StringBuilderdoivent être utilisés.

Pour plus d'informations, consultez ce site .

string.Join () vs string.Concat ()

La méthode string.Concat ici est équivalente à l'invocation de la méthode string.Join avec un séparateur vide. Ajouter une chaîne vide est rapide, mais ne pas le faire est encore plus rapide, donc la méthode string.Concat serait supérieure ici.

Depuis Chinh Do - StringBuilder n'est pas toujours plus rapide :

Règles de base

• Lors de la concaténation de trois valeurs de chaîne dynamique ou moins, utilisez la concaténation de chaîne traditionnelle.

• Lors de la concaténation de plus de trois valeurs de chaîne dynamique, utilisez StringBuilder.

• Lorsque vous créez une grande chaîne à partir de plusieurs littéraux de chaîne, utilisez soit le @littéral de chaîne, soit l'opérateur inline +.

La plupart du temps StringBuilderest votre meilleur pari, mais il y a des cas, comme indiqué dans ce post, que vous devriez au moins penser à chaque situation.

Si vous travaillez en boucle, StringBuilderc'est probablement la voie à suivre; cela vous évite d'avoir à créer régulièrement de nouvelles chaînes. Dans le code, cela ne fonctionnera qu'une seule fois, String.Concatc'est probablement bien.

Cependant, Rico Mariani (gourou de l'optimisation .NET) a composé un quiz dans lequel il a déclaré à la fin que, dans la plupart des cas, il recommande String.Format.

Voici la méthode la plus rapide que j'ai développée au cours d'une décennie pour mon application NLP à grande échelle. J'ai des variations pour IEnumerable<T>et d'autres types d'entrée, avec et sans séparateurs de différents types ( Char, String), mais ici je montre le cas simple de la concaténation de toutes les chaînes d'un tableau en une seule chaîne, sans séparateur. La dernière version ici est développée et testée à l'unité sur C # 7 et .NET 4.7 .

Il existe deux clés pour des performances plus élevées; la première consiste à pré-calculer la taille totale exacte requise. Cette étape est triviale lorsque l'entrée est un tableau comme illustré ici. Pour la gestion à la IEnumerable<T>place, il convient de rassembler d'abord les chaînes dans un tableau temporaire pour calculer ce total (le tableau est nécessaire pour éviter d'appeler ToString()plus d'une fois par élément car techniquement, étant donné la possibilité d'effets secondaires, cela pourrait changer la sémantique attendue d'une opération de "jointure de chaîne").

Ensuite, étant donné la taille totale de l'allocation de la chaîne finale, la plus grande amélioration des performances est obtenue en créant la chaîne de résultat en place . Cela nécessite la technique (peut-être controversée) de suspendre temporairement l'immuabilité d'un nouveau Stringqui est initialement alloué plein de zéros. Une telle controverse mise à part, cependant ...

... notez qu'il s'agit de la seule solution de concaténation en masse sur cette page qui évite entièrement un tour supplémentaire d'allocation et de copie par le Stringconstructeur.

Code complet:

/// <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);

Je dois mentionner que ce code a une légère modification de ce que j'utilise moi-même. Dans l'original, j'appelle l' instruction cpblk IL à partir de C # pour effectuer la copie réelle. Pour plus de simplicité et de portabilité dans le code ici, j'ai remplacé cela par P / Invoke à la memcpyplace, comme vous pouvez le voir. Pour des performances optimales sur x64 ( mais peut-être pas x86 ), vous souhaiterez peut-être utiliser la méthode cpblk à la place.

De cet article MSDN :

Il y a une surcharge associée à la création d'un objet StringBuilder, à la fois en temps et en mémoire. Sur une machine à mémoire rapide, un StringBuilder vaut la peine si vous effectuez environ cinq opérations. En règle générale, je dirais que 10 opérations de chaîne ou plus sont une justification de la surcharge sur n'importe quelle machine, même plus lente.

Donc, si vous faites confiance à MSDN, utilisez StringBuilder si vous devez effectuer plus de 10 opérations / concaténations de chaînes - sinon, une simple concaténation de chaînes avec «+» est très bien.

Il est également important de souligner que vous devez utiliser l' +opérateur si vous concaténez des littéraux de chaîne .

Lorsque vous concaténez des littéraux de chaîne ou des constantes de chaîne à l'aide de l'opérateur +, le compilateur crée une seule chaîne. Aucune concaténation d'exécution ne se produit.

Comment: concaténer plusieurs chaînes (Guide de programmation C #)

En ajoutant aux autres réponses, veuillez garder à l'esprit que StringBuilder peut recevoir une quantité initiale de mémoire à allouer .

Le paramètre de capacité définit le nombre maximal de caractères pouvant être stockés dans la mémoire allouée par l'instance actuelle. Sa valeur est affectée à la propriété Capacity . Si le nombre de caractères à stocker dans l'instance actuelle dépasse cette valeur de capacité , l'objet StringBuilder alloue de la mémoire supplémentaire pour les stocker.

Si la capacité est nulle, la capacité par défaut spécifique à l'implémentation est utilisée.

L'ajout répété à un StringBuilder qui n'a pas été pré-alloué peut entraîner de nombreuses allocations inutiles, tout comme la concaténation répétée de chaînes régulières.

Si vous savez combien de temps durera la chaîne finale, pouvez la calculer trivialement ou faire une supposition éclairée sur le cas commun (allouer trop n'est pas nécessairement une mauvaise chose), vous devez fournir ces informations au constructeur ou au Propriété de capacité . Surtout lors de l'exécution de tests de performances pour comparer StringBuilder avec d'autres méthodes comme String.Concat, qui font la même chose en interne. Tout test que vous voyez en ligne qui n'inclut pas la pré-allocation de StringBuilder dans ses comparaisons est faux.

Si vous ne pouvez pas deviner la taille, vous écrivez probablement une fonction utilitaire qui devrait avoir son propre argument facultatif pour contrôler la pré-allocation.

Voici peut-être une autre solution alternative pour concaténer plusieurs chaînes.

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

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

interpolation de chaîne

Le plus efficace est d'utiliser StringBuilder, comme ceci:

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

@jonezy: String.Concat est très bien si vous avez quelques petites choses. Mais si vous concaténez des mégaoctets de données, votre programme sera probablement chargé.

Essayez ces 2 morceaux de code et vous trouverez la solution.

 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();
    }

Contre

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

Vous constaterez que le 1er code se terminera très rapidement et la mémoire sera en bonne quantité.

Le deuxième code peut-être que la mémoire sera correcte, mais cela prendra plus de temps ... beaucoup plus de temps. Donc, si vous avez une application pour beaucoup d'utilisateurs et que vous avez besoin de vitesse, utilisez la 1ère. Si vous avez une application pour une application utilisateur à court terme, vous pouvez peut-être utiliser les deux ou la seconde sera plus "naturelle" pour les développeurs.

À votre santé.

Pour seulement deux chaînes, vous ne voulez certainement pas utiliser StringBuilder. Il existe un certain seuil au-dessus duquel la surcharge de StringBuilder est inférieure à la surcharge d'allocation de plusieurs chaînes.

Donc, pour plus de 2-3 chaînes, utilisez le code de DannySmurf . Sinon, utilisez simplement l'opérateur +.

System.String est immuable. Lorsque nous modifions la valeur d'une variable de chaîne, une nouvelle mémoire est allouée à la nouvelle valeur et l'allocation de mémoire précédente libérée. System.StringBuilder a été conçu pour avoir le concept d'une chaîne mutable où une variété d'opérations peuvent être effectuées sans attribuer un emplacement de mémoire séparé pour la chaîne modifiée.

Une autre solution:

à l'intérieur de la boucle, utilisez List au lieu de string.

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

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

c'est très très rapide.

Cela dépend vraiment de votre modèle d'utilisation. Une référence détaillée entre string.Join, string, Concat et string.Format peut être trouvée ici: String.Format ne convient pas pour une journalisation intensive

(C'est en fait la même réponse que j'ai donnée à cette question)

Cela dépendrait du code. StringBuilder est généralement plus efficace, mais si vous concaténez seulement quelques chaînes et faites tout cela sur une seule ligne, les optimisations de code s'en occuperont probablement pour vous. Il est important de penser à quoi ressemble le code: pour les ensembles plus grands, StringBuilder facilitera la lecture, pour les petits, StringBuilder ajoutera simplement un encombrement inutile.