StringBuilder.Ajouter Vs StringBuilder.AppendFormat

casperOne est correct . Une fois que vous atteignez un certain seuil, la méthode Append() devient plus lente que AppendFormat() . Voici les différentes longueurs et les tiques de 100.000 itérations de chaque méthode:

Longueur: 1

Append()       - 50900
AppendFormat() - 126826

Longueur: 1000

Append()       - 1241938
AppendFormat() - 1337396

Longueur: 10,000

Append()       - 12482051
AppendFormat() - 12740862

Longueur: 20,000

Append()       - 61029875
AppendFormat() - 60483914

quand les cordes d'une longueur proche de 20.000 sont introduites, la fonction AppendFormat() sera légèrement surperform Append() .

pourquoi cela arrive-t-il? Voir réponse de casperOne .

Edit:

I reran chaque test individuellement sous la configuration de libération et mis à jour les résultats.

casperOne est tout à fait exact qu'il dépend des données . Cependant, supposons que vous écriviez ceci comme une bibliothèque de classe pour les tiers à consommer - qui utiliseriez-vous?

une option serait d'obtenir le meilleur des deux mondes - calculer combien de données vous allez réellement avoir à ajouter, puis utiliser StringBuilder.EnsureCapacity pour s'assurer que nous n'avons besoin que d'un seul tampon redimensionné.

si Je n'étais pas trop gêné cependant, j'utiliserais Append x3 - il semble "plus probable" d'être plus rapide, comme l'analyse du format de chaîne de caractères sur chaque appel est clairement make-work.

notez que j'ai demandé à L'équipe BCL une sorte de "formatteur en cache" que nous pourrions créer en utilisant une chaîne de format puis réutiliser à plusieurs reprises. C'est fou que le cadre doit analyser la chaîne de format à chaque fois qu'il est utilisé.

EDIT: Bon, j'ai édité John code un peu pour la flexibilité et a ajouté un "Appendicwithcapacity" qui vient de travailler sur la capacité nécessaire d'abord. Voici les résultats pour les différentes longueurs - pour la longueur 1 j'ai utilisé 1.000.000 itérations; pour toutes les autres longueurs j'ai utilisé 100.000. (Ceci était juste pour obtenir des temps de course raisonnables.) Toutes les heures sont en millis.

malheureusement les tables ne fonctionnent pas vraiment ainsi. Les longueurs étaient 1, 1000, 10000, 20000

Times:

• annexe: 162, 475, 7997, 17970
• AppendFormat: 392, 499, 8541, 18993
• Appendicavec capacité: 139, 189, 1558, 3085

ainsi comme il s'est produit, je n'ai jamais vu AppendFormat beat Ajouter - mais je did voir Appendicwithcapacity gagner par une marge très substantielle.

voici le code complet:

using System;
using System.Diagnostics;
using System.Text;

public class StringBuilderTest
{            
    static void Append(string string1, string string2)
    {
        StringBuilder sb = new StringBuilder();
        sb.Append(string1);
        sb.Append("----");
        sb.Append(string2);
    }

    static void AppendWithCapacity(string string1, string string2)
    {
        int capacity = string1.Length + string2.Length + 4;
        StringBuilder sb = new StringBuilder(capacity);
        sb.Append(string1);
        sb.Append("----");
        sb.Append(string2);
    }

    static void AppendFormat(string string1, string string2)
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendFormat("{0}----{1}", string1, string2);
    }

    static void Main(string[] args)
    {
        int size = int.Parse(args[0]);
        int iterations = int.Parse(args[1]);
        string method = args[2];

        Action<string,string> action;
        switch (method)
        {
            case "Append": action = Append; break;
            case "AppendWithCapacity": action = AppendWithCapacity; break;
            case "AppendFormat": action = AppendFormat; break;
            default: throw new ArgumentException();
        }

        string string1 = new string('x', size);
        string string2 = new string('y', size);

        // Make sure it's JITted
        action(string1, string2);
        GC.Collect();

        Stopwatch sw = Stopwatch.StartNew();
        for (int i=0; i < iterations; i++)
        {
            action(string1, string2);
        }
        sw.Stop();
        Console.WriteLine("Time: {0}ms", (int) sw.ElapsedMilliseconds);
    }
}

Append sera plus rapide dans la plupart des cas parce qu'il y a beaucoup de surcharges à cette méthode qui permettent au compilateur d'appeler la bonne méthode. Puisque vous utilisez Strings le StringBuilder peut utiliser le String surcharge pour Append .

AppendFormat prend un String puis un Object[] , ce qui signifie que le format devra être analysé et chaque Object dans le tableau devra être ToString'd avant d'être ajoutée à la StringBuilder's tableau interne.

Note: à la pointe de casperOne - il est difficile de donner une réponse exacte sans plus de données.

StringBuilder a aussi des appendices en cascade: Append() renvoie le StringBuilder lui-même, de sorte que vous pouvez écrire votre code comme ceci:

StringBuilder sb = new StringBuilder();
sb.Append(string1)
  .Append("----")
  .Append(string2);

propre, et il génère moins de IL-code (bien que ce soit vraiment une micro-optimisation).

de profil de cours pour en être sûr dans chaque cas.

cela dit, je pense qu'en général, il sera l'ex parce que vous n'êtes pas à plusieurs reprises l'analyse de la chaîne de format.

Cependant, la différence serait très faible. Au point que vous devriez vraiment envisager d'utiliser AppendFormat dans la plupart des cas de toute façon.

je suppose que c'était l'appel que fait le moins de travail. Append ne fait que concaténer les cordes, où AppendFormat fait des substitutions de cordes. Bien sûr, ces jours, vous ne pouvez jamais dire...

1 devrait être plus rapide car il s'agit simplement d'ajouter les chaînes alors que 2 doit créer une chaîne basée sur un format et ensuite ajouter la chaîne. Donc, il y a une étape supplémentaire.

plus rapide est 1 dans votre cas mais ce n'est pas une comparaison équitable. Vous devriez demander à StringBuilder.AppendFormat () vs StringBuilder.Append(string.Format ()) - où le premier est plus rapide en raison du travail interne avec le tableau de char.

Votre deuxième option est plus lisible.