Est Une Chaîne.Format aussi efficace que StringBuilder

REMARQUE: Cette réponse a été écrit quand .NET 2.0 est la version actuelle. Cela peut ne plus s'appliquer aux versions ultérieures.

String.Format utilise un StringBuilder en interne:

public static string Format(IFormatProvider provider, string format, params object[] args)
{
    if ((format == null) || (args == null))
    {
        throw new ArgumentNullException((format == null) ? "format" : "args");
    }

    StringBuilder builder = new StringBuilder(format.Length + (args.Length * 8));
    builder.AppendFormat(provider, format, args);
    return builder.ToString();
}

Le code ci-dessus est un extrait de mscorlib, donc la question se pose "est StringBuilder.Append() plus vite que StringBuilder.AppendFormat()"?

Sans benchmarking, je dirais probablement que l'exemple de code ci-dessus s'exécuter plus rapidement en utilisant .Append(). Mais c'est une supposition, essayez d'analyse comparative et/ou de profilage les deux pour en faire une véritable comparaison.

Ce chap, Jerry Dixon, fait un peu de benchmarking:

http://jdixon.dotnetdevelopersjournal.com/string_concatenation_stringbuilder_and_stringformat.htm

Mise à jour:

Malheureusement le lien ci-dessus est décédé depuis. Toutefois, il y a toujours une copie sur le Chemin du Retour de la Machine:

http://web.archive.org/web/20090417100252/http://jdixon.dotnetdevelopersjournal.com/string_concatenation_stringbuilder_and_stringformat.htm

À la fin de la journée cela dépend si votre chaîne de formatage va être appelée de façon répétitive, c'est à dire, vous faites des graves de traitement de texte de plus de 100 méga-octets de texte, ou s'il est appelé lorsque l'utilisateur clique sur un bouton maintenant et encore. Sauf si vous êtes en train de faire un énorme lot de traitement d'emploi que j'ai coller avec de la Ficelle.Format, il contribue à la lisibilité du code. Si vous soupçonnez une perf goulot d'étranglement puis coller un profiler sur votre code et de voir où il est vraiment.

J'ai couru quelques tests de performance, et pour 100 000 opérations en moyenne plus de 10 pistes, la première méthode (String Builder) prend presque la moitié du temps de la seconde (Format de Chaîne de caractères).

Donc, si cela est rare, il n'a pas d'importance. Mais si c'est une opération courante, alors vous pouvez utiliser la première méthode.

Si seulement en raison de la chaîne.Format n'est pas exactement ce que vous pourriez penser, voici une reprise de l'tests 6 ans plus tard, Net45.

Concat est encore plus rapide, mais vraiment, c'est moins de 30% de différence. StringBuilder et Format diffèrent à peine de 5 à 10%. J'ai eu des variations de 20% d'exécuter les tests un peu de temps.

Millisecondes, un million d'itérations:

• Concaténation: 367
• New stringBuilder pour chaque touche: 452
• Cache StringBuilder: 419
• chaîne.Format: 475

La leçon que je retiens, c'est que la différence de performances est trivial et donc il ne devrait pas vous arrêter de l'écriture la plus simple lisible le code vous pouvez. Qui pour mon argent est souvent, mais pas toujours a + b + c.

const int iterations=1000000;
var keyprefix= this.GetType().FullName;
var maxkeylength=keyprefix + 1 + 1+ Math.Log10(iterations);
Console.WriteLine("KeyPrefix \"{0}\", Max Key Length {1}",keyprefix, maxkeylength);
var concatkeys= new string[iterations];
var stringbuilderkeys= new string[iterations];
var cachedsbkeys= new string[iterations];
var formatkeys= new string[iterations];
var stopwatch= new System.Diagnostics.Stopwatch();
Console.WriteLine("Concatenation:");
stopwatch.Start();
for(int i=0; i<iterations; i++){
var key1= keyprefix+":" + i.ToString();
concatkeys[i]=key1;
}
Console.WriteLine(stopwatch.ElapsedMilliseconds);
Console.WriteLine("New stringBuilder for each key:");
stopwatch.Restart();
for(int i=0; i<iterations; i++){
var key2= new StringBuilder(keyprefix).Append(":").Append(i.ToString()).ToString();
stringbuilderkeys[i]= key2;
}
Console.WriteLine(stopwatch.ElapsedMilliseconds);
Console.WriteLine("Cached StringBuilder:");
var cachedSB= new StringBuilder(maxkeylength);
stopwatch.Restart();
for(int i=0; i<iterations; i++){
var key2b= cachedSB.Clear().Append(keyprefix).Append(":").Append(i.ToString()).ToString();
cachedsbkeys[i]= key2b;
}
Console.WriteLine(stopwatch.ElapsedMilliseconds);
Console.WriteLine("string.Format");
stopwatch.Restart();
for(int i=0; i<iterations; i++){
var key3= string.Format("{0}:{1}", keyprefix,i.ToString());
formatkeys[i]= key3;
}
Console.WriteLine(stopwatch.ElapsedMilliseconds);
var referToTheComputedValuesSoCompilerCantOptimiseTheLoopsAway= concatkeys.Union(stringbuilderkeys).Union(cachedsbkeys).Union(formatkeys).LastOrDefault(x=>x[1]=='-');
Console.WriteLine(referToTheComputedValuesSoCompilerCantOptimiseTheLoopsAway);

Chaîne.Format utilise StringBuilder en interne...donc, logiquement, qui mène à l'idée qu'il serait un peu moins performant en raison de plus de surcharge. Toutefois, une simple concaténation de chaîne est la méthode la plus rapide de l'injection d'une chaîne de caractères entre les deux others...by un degré significatif. Cette preuve a été démontré par Rico Mariani dans sa première Performance d'un Questionnaire, il y a des années. Simple fait est que les concaténations de...lorsque le nombre de parties de chaîne est connue (sans limitation..on peut concaténer un millier de pièces...aussi longtemps que vous savez c'est toujours 1000 pièces)...sont toujours plus vite que StringBuilder ou Chaîne.Format. Ils peuvent être réalisées avec une seule allocation de mémoire une série de la mémoire des copies. Ici est la preuve

Et voici le code pour une Chaîne de caractères.Concat méthodes, qui finalement l'appel FillStringChecked qui utilise des pointeurs pour copier de la mémoire (extraite par de l'Réflecteur):

public static string Concat(params string[] values)
{
int totalLength = 0;
if (values == null)
{
throw new ArgumentNullException("values");
}
string[] strArray = new string[values.Length];
for (int i = 0; i < values.Length; i++)
{
string str = values[i];
strArray[i] = (str == null) ? Empty : str;
totalLength += strArray[i].Length;
if (totalLength < 0)
{
throw new OutOfMemoryException();
}
}
return ConcatArray(strArray, totalLength);
}
public static string Concat(string str0, string str1, string str2, string str3)
{
if (((str0 == null) && (str1 == null)) && ((str2 == null) && (str3 == null)))
{
return Empty;
}
if (str0 == null)
{
str0 = Empty;
}
if (str1 == null)
{
str1 = Empty;
}
if (str2 == null)
{
str2 = Empty;
}
if (str3 == null)
{
str3 = Empty;
}
int length = ((str0.Length + str1.Length) + str2.Length) + str3.Length;
string dest = FastAllocateString(length);
FillStringChecked(dest, 0, str0);
FillStringChecked(dest, str0.Length, str1);
FillStringChecked(dest, str0.Length + str1.Length, str2);
FillStringChecked(dest, (str0.Length + str1.Length) + str2.Length, str3);
return dest;
}
private static string ConcatArray(string[] values, int totalLength)
{
string dest = FastAllocateString(totalLength);
int destPos = 0;
for (int i = 0; i < values.Length; i++)
{
FillStringChecked(dest, destPos, values[i]);
destPos += values[i].Length;
}
return dest;
}
private static unsafe void FillStringChecked(string dest, int destPos, string src)
{
int length = src.Length;
if (length > (dest.Length - destPos))
{
throw new IndexOutOfRangeException();
}
fixed (char* chRef = &dest.m_firstChar)
{
fixed (char* chRef2 = &src.m_firstChar)
{
wstrcpy(chRef + destPos, chRef2, length);
}
}
}

Alors:

string what = "cat";
string inthehat = "The " + what + " in the hat!";

Profitez-en!

Ça dépend vraiment. Pour les petites chaînes avec quelques enchaînements, il est effectivement plus rapide juste pour ajouter les chaînes.

String s = "String A" + "String B";

Mais pour la plus grande chaîne de (très très grandes chaînes de caractères), il est donc plus efficace à utiliser StringBuilder.

Cela dépend vraiment de votre modèle d'utilisation.

Détaillée de référence entre string.Join, string,Concat et string.Format peut être trouvé ici: Chaîne de caractères.Le Format N'est pas Adapté pour l'exploitation forestière Intensive