stringbuilder contre chaîne concat

Dans mon projet, je suis en boucle sur un dataview résultat.

 string html =string.empty;
 DataView dV = data.DefaultView;
 for(int i=0;i< dV.Count;i++)
 {
     DataRowView rv = dV[i];
     html += rv.Row["X"].Tostring();
 }

Nombre de lignes dans vq toujours être 3 ou 4.

Est-il préférable d'utiliser la chaîne concat += opearator ou StringBuilder pour ce cas et pourquoi?

source d'informationauteur Niraj Choubey

  1. 32

    Je voudrais utiliser StringBuilder ici, juste parce qu'il décrit ce que vous faites.

    Pour une simple concaténation de 3 ou 4 cordes, il ne sera probablement pas faire de différence significative, et la concaténation de chaîne peut même être légèrement plus rapide, mais si vous vous trompez, et il y a beaucoup de lignes, StringBuilder commencera à obtenir beaucoup plus efficace, et c'est toujours plus descriptif de ce que vous faites.

    Sinon, vous pouvez utiliser quelque chose comme:

    string html = string.Join("", dv.Cast<DataRowView>()
                                .Select(rv => rv.Row["X"]));

    Notez que vous n'avez pas toute sorte de séparateur entre les cordes pour le moment. Êtes-vous sûr que ce que vous voulez? (Notez également que votre code ne fait pas beaucoup de sens à l'instant - vous ne l'utilisez pas i dans la boucle. Pourquoi?)

    J'ai un article sur la concaténation de chaîne qui va plus dans le détail sur pourquoi il vaut la peine de l'aide StringBuilder et quand.

    EDIT: Pour ceux qui doutent que la concaténation de chaîne peut être plus rapide, voici un test - volontairement "méchant" de données, mais juste pour prouver que c'est possible:

    using System;
using System.Diagnostics;
using System.Text;
class Test
{
static readonly string[] Bits = { 
"small string",
"string which is a bit longer",
"stirng which is longer again to force yet another copy with any luck"
};
static readonly int ExpectedLength = string.Join("", Bits).Length;
static void Main()        
{
Time(StringBuilderTest);
Time(ConcatenateTest);
}
static void Time(Action action)
{
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
//Make sure it's JITted
action();
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < 10000000; i++)
{
action();
}
sw.Stop();
Console.WriteLine("{0}: {1} millis", action.Method.Name,
(long) sw.Elapsed.TotalMilliseconds);
}
static void ConcatenateTest()
{
string x = "";
foreach (string bit in Bits)
{
x += bit;
}
//Force a validation to prevent dodgy optimizations
if (x.Length != ExpectedLength)
{
throw new Exception("Eek!");
}
}
static void StringBuilderTest()
{
StringBuilder builder = new StringBuilder();
foreach (string bit in Bits)
{
builder.Append(bit);
}
string x = builder.ToString();
//Force a validation to prevent dodgy optimizations
if (x.Length != ExpectedLength)
{
throw new Exception("Eek!");
}
}
}

    Résultats sur ma machine (compilé avec /o+ /debug-):

    StringBuilderTest: 2245 millis
ConcatenateTest: 989 millis

    J'ai couru plusieurs fois, y compris l'inversion de l'ordre des tests, et les résultats sont cohérents.

  2. 4

    StringBuilder est recommandé.. pourquoi ne pas vous faire une analyse pour vous-même et de décider ensuite ce qui est le mieux pour vous..

    var stopWatch=new StopWatch();
stopWatch.Start();
string html =string.empty;
DataView dV = data.DefaultView;
for(int i=0;i< dV.Count;i++)
{
html += dV.Row["X"].Tostring();
} 
stopWatch.Stop();
Console.Write(stopWatch.EllapsedMilliseconds());
var stopWatch=new StopWatch();
stopWatch.Start();
string html =new StringBuilder();
DataView dV = data.DefaultView;
for(int i=0;i< dV.Count;i++)
{
html.Append(dV.Row["X"].ToString());
} 
var finalHtml=html.ToString();
stopWatch.Stop();
Console.Write(stopWatch.EllapsedMilliseconds());
  3. 2

    À partir de la Documentation:

    La classe String est préférable pour une opération de concaténation si un
    nombre fixe d'objets String sont concaténées. Dans ce cas, l'
    personne concaténation des opérations pourrait même être combinés en un
    seule opération par le compilateur.

    Un objet StringBuilder est préférable pour une opération de concaténation si
    un nombre arbitraire de chaînes sont concaténées; par exemple, si un
    boucle concatène un nombre aléatoire de chaînes de saisie de l'utilisateur.

    Donc dans votre cas, je dirais que la Chaîne est mieux.

    EDIT:

    Que ce n'est pas la fin de disscussion, de toute façon, je vous recommande de vérifier combien de opaeration avez-vous en moyenne et de tester la performance de chacun d'entre eux à comparer les résultats.

    Cochez cette lien sympa sur cette question, y compris certains de test de performance du code.

  4. 1

    StringBuilder pour vous. Chaîne sont immuables, n'oubliez pas !

    EDIT: Pour les 3-4 lignes, la concaténation sera un choix préféré que Jon Skeet a dit dans sa réponse

  5. 1

    StringBuilder est recommandé. Il est mutable. Elle doit aussi beaucoup moins de stress sur l'allocateur de mémoire 🙂

    Une instance string est immuable. Vous ne pouvez pas le changer après qu'il a été
    créée.
    Toute opération qui s'affiche pour modifier la chaîne au lieu de cela renvoie une nouvelle instance.

  6. 0

    stringbuilder est ce que vous cherchez. En général, si il y a une fonction pour certains emplois essayer de l'utiliser au lieu d'écrire une procédure qui fait à peu près le même travail.