Quelle méthode concaténation de chaîne à utiliser pour le nombre d'itérations N?

Question

Si je veux concaténer un numéro de chaîne de N fois, quelle méthode je préfère?

Prenez ce code comme exemple:

public static string Repeat(this string instance, int times)
{
        var result = string.Empty;

        for (int i = 0; i < times; i++)
            result += instance;

        return result;
}

Cette méthode peut être invoquée avec « temps » fixé à 5 ou 5000. Quelle méthode devrais-je préfère utiliser?

string.join? Stringbuilder? Juste String.Concat norme?

Une fonction similaire va être mis en œuvre dans une bibliothèque commerciale donc je vraiment besoin de la façon « optimale » pour le faire.

Answer 1

    public static string Repeat(this string instance, int times)
    {
        if (times == 1 || string.IsNullOrEmpty(instance)) return instance;
        if (times == 0) return "";
        if (times < 0) throw new ArgumentOutOfRangeException("times");
        StringBuilder sb = new StringBuilder(instance.Length * times);
        for (int i = 0; i < times; i++)
            sb.Append(instance);
        return sb.ToString();
    }

Answer 2

stringbuilder ofcourse. Il est destiné à la chaîne rapide des opérations de jointure, car il ne sera pas créer de nouveaux objets chaque fois que vous souhaitez rejoindre une chaîne.

Pour plus de détails voir ici .

Answer 3

StringBuilder.

"résultat + = résultat;"

crée une nouvelle chaîne chaque fois que vous faites l'affectation et assignez cette nouvelle chaîne à votre variable, puisque les chaînes sont immuables.

Allez avec StringBuilder, sans aucun doute.

Answer 4

Ne jamais faire une hypothèse qu'une méthode est plus rapide qu'un autre - vous devez alway mesurer la performance des deux et ensuite décider

.

De façon surprenante, pour un plus petit nombre d'itérations, juste une concaténation de chaîne standard (résultat = + string) est souvent plus rapide que d'utiliser un constructeur de chaîne.

Si vous savez que le nombre d'itérations sera toujours le même (par exemple, il sera toujours 50 itérations), alors je suggère que vous faites des mesures de performance en utilisant différentes méthodes.

Si vous vraiment veulent obtenir intelligent, effectuer des mesures de performance par rapport au nombre d'itérations et vous pouvez trouver le « point de croisement » où une méthode est plus rapide que l'autre et coder en dur ce seuil dans la méthode :

if(iterations < 30)
{
    CopyWithConcatenation();
}
else
{
    CopyWithStringBuilder();
}

Le point de croisement de la performance exacte dépendra du détail spécifique de votre code et vous ne serez jamais en mesure de savoir ce qu'ils sont sans mesures de performance.

Pour compliquer les choses un peu plus, StringBuilder a « plus propre » gestion de la mémoire de concaténation de chaîne (qui crée des instances plus temporaires) donc cela pourrait aussi avoir un impact sur la performance globale en dehors de la boucle de chaîne (comme la prochaine fois que le Garbage Collector court).

Faites-nous savoir comment vous avez sur.