[C#] Le moyen le plus efficace de concaténer les chaînes?


Answers

Rico Mariani , le gourou .NET Performance, avait un article sur ce sujet. Ce n'est pas aussi simple qu'on pourrait le penser. Le conseil de base est celui-ci:

Si votre motif ressemble à:

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

c'est une concat et c'est zippy, StringBuilder ne va probablement pas aider.

Si votre motif ressemble à:

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

alors vous voulez probablement StringBuilder.

Encore un autre article pour soutenir cette affirmation vient d'Eric Lippert où il décrit les optimisations effectuées sur une ligne + concaténations de manière détaillée.

Question

Quel est le moyen le plus efficace de concaténer les chaînes?




Cela dépend du code. StringBuilder est généralement plus efficace, mais si vous ne faites que concaténer quelques chaînes et que vous faites tout en une ligne, les optimisations de code s'en chargeront probablement pour vous. Il est important de réfléchir à l'aspect du code: pour les plus grands, StringBuilder le rendra plus facile à lire, pour les plus petits, StringBuilder ajoutera simplement un fouillis inutile.




Essayez ce 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 trouverez que le 1er code se terminera très rapidement et la mémoire sera dans une bonne proportion.

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

À votre santé.







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 bien si vous avez quelques petites choses. Mais si vous concaténez des mégaoctets de données, votre programme sera probablement tanké.




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

Règles de base

  • Lorsque vous enchaînez trois valeurs de chaînes dynamiques ou moins, utilisez la concaténation de chaînes traditionnelle.

  • Lorsque vous concaténez plus de trois valeurs de chaînes dynamiques, utilisez StringBuilder.

  • Lors de la construction d'une grande chaîne à partir de plusieurs chaînes littérales, utilisez le littéral @ chaîne ou l'opérateur inline +.

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




De cet article MSDN :

Une surcharge est associée à la création d'un objet StringBuilder, à la fois dans le temps et dans la mémoire. Sur une machine avec mémoire rapide, un StringBuilder devient intéressant si vous faites environ cinq opérations. En règle générale, je dirais 10 opérations de chaîne ou plus est une justification de la surcharge sur n'importe quelle machine, même une plus lente.

Donc, si vous faites confiance à MSDN allez avec StringBuilder si vous devez faire plus de 10 opérations / concaténations de chaînes - sinon la concaténation de chaîne simple avec '+' est bien.