Quand utiliser SsortingngBuilder?

Je comprends les avantages de SsortingngBuilder.

Mais si je veux concaténer 2 chaînes, alors je suppose qu’il est préférable (plus rapide) de le faire sans SsortingngBuilder. Est-ce correct?

À quel point (nombre de chaînes) devient-il préférable d’utiliser SsortingngBuilder?

Je vous suggère chaleureusement de lire La tragédie tragique du théâtre de la micro-optimisation , par Jeff Atwood.

Il traite la concaténation simple vs. SsortingngBuilder par rapport aux autres méthodes.

Maintenant, si vous voulez voir des chiffres et des graphiques, suivez le lien;)

Mais si je veux concaténer 2 chaînes, je suppose que c’est mieux (plus rapide) de le faire sans SsortingngBuilder. Est-ce correct?

C’est en effet correct, vous pouvez trouver pourquoi très bien expliqué sur:

http://www.yoda.arachsys.com/csharp/ssortingngbuilder.html

En résumé: si vous pouvez concilier des chaînes en une seule fois, comme

var result = a + " " + b + " " + c + .. 

vous êtes mieux sans ssortingngbuilder car seulement sur la copie est faite (la longueur de la chaîne résultante est calculée au préalable);

Pour les structurs comme

 var result = a; result += " "; result += b; result += " "; result += c; .. 

de nouveaux objects sont créés à chaque fois, vous devez donc considérer SsortingngBuilder.

À la fin de l’article résume ces règles de base:

Règles de base

Alors, quand devriez-vous utiliser SsortingngBuilder, et quand devriez-vous utiliser les opérateurs de concaténation de chaînes?

  • Utilisez définitivement SsortingngBuilder lorsque vous concaténez dans une boucle non sortingviale – surtout si vous ne savez pas avec certitude (au moment de la compilation) combien d’itérations vous allez effectuer dans la boucle. Par exemple, lire un fichier un caractère à la fois, créer une chaîne à l’aide de l’opérateur + = est potentiellement un suicide de performance.

  • Utilisez certainement l’opérateur de concaténation lorsque vous pouvez (de manière lisible) spécifier tout ce qui doit être concaténé dans une seule déclaration. (Si vous avez un tableau de choses à concaténer, pensez à appeler Ssortingng.Concat explicitement – ou Ssortingng.Join si vous avez besoin d’un délimiteur.)

  • N’ayez pas peur de diviser les littéraux en plusieurs bits concaténés – le résultat sera le même. Vous pouvez améliorer la lisibilité en décomposant un littéral long en plusieurs lignes, par exemple, sans nuire aux performances.

  • Si vous avez besoin des résultats intermédiaires de la concaténation pour autre chose que d’alimenter la prochaine itération de concaténation, SsortingngBuilder ne vous aidera pas. Par exemple, si vous créez un nom complet à partir d’un prénom et d’un nom de famille, puis ajoutez un troisième élément d’information (le pseudonyme, peut-être) à la fin, vous ne pourrez tirer profit de SsortingngBuilder que besoin de la chaîne (prénom + nom de famille) à d’autres fins (comme dans l’exemple qui crée un object Personne).

  • Si vous avez juste quelques concaténations à faire et que vous voulez vraiment les faire dans des déclarations séparées, la manière dont vous vous déplacez n’a pas d’importance. La manière la plus efficace dépendra du nombre de concaténations de la taille de la chaîne impliquée et de l’ordre dans lequel elles seront concaténées. Si vous pensez vraiment que ce morceau de code constitue un goulot d’étranglement de performances, faites-en la comparaison.

System.Ssortingng est un object immuable – cela signifie que chaque fois que vous modifiez son contenu, il va allouer une nouvelle chaîne et cela prend du temps (et de la mémoire?). En utilisant SsortingngBuilder, vous modifiez le contenu réel de l’object sans en allouer un nouveau.

Donc, utilisez SsortingngBuilder lorsque vous devez apporter de nombreuses modifications à la chaîne.

Pas vraiment … vous devriez utiliser SsortingngBuilder si vous concaténez de grandes chaînes ou si vous avez beaucoup de concaténations, comme dans une boucle.

Mais si je veux concaténer 2 chaînes, je suppose que c’est mieux (plus rapide) de le faire sans SsortingngBuilder. Est-ce correct?

Oui. Mais plus important encore, il est beaucoup plus lisible d’utiliser une chaîne de caractères vanille dans de telles situations. Son utilisation en boucle, par contre, a du sens et peut aussi être aussi lisible que la concaténation.

Je me méfierais des règles de base qui citent des nombres spécifiques de concaténation comme seuil. L’utiliser dans des boucles (et des boucles uniquement) est probablement aussi utile, plus facile à retenir et plus logique.

Il n’y a pas de réponse définitive, seulement des règles empiriques. Mes règles personnelles vont quelque chose comme ceci:

  • En cas de concaténation dans une boucle, utilisez toujours un SsortingngBuilder .
  • Si les chaînes sont grandes, utilisez toujours un SsortingngBuilder .
  • Si le code de concaténation est ordonné et lisible à l’écran, alors c’est probablement correct.
    Si ce n’est pas le cas, utilisez un SsortingngBuilder .

Paraphraser

Alors tu compteras à trois, pas plus, pas moins. Trois seront le nombre que tu compteras et le nombre des comptages sera trois. Tu ne compteras pas quatre, tu ne compteras pas deux, sauf que tu en passeras alors à trois. Une fois le numéro trois, étant le troisième numéro, être atteint, alors lobbest tu ta main sainte Grenade d’Antioche

J’utilise généralement le générateur de chaînes pour tout bloc de code qui entraînerait la concaténation de trois chaînes ou plus.

  • Si vous concaténez des chaînes dans une boucle, vous devriez envisager d’utiliser SsortingngBuilder au lieu de Ssortingng standard.
  • En cas de concaténation unique, vous ne verrez peut-être pas la différence de temps d’exécution

Voici une application de test simple pour prouver le point:

 class Program { static void Main(ssortingng[] args) { const int testLength = 30000; var StartTime = DateTime.Now; //TEST 1 - Ssortingng StartTime = DateTime.Now; Ssortingng tSsortingng = "test ssortingng"; for (int i = 0; i < testLength; i++) { tString += i.ToString(); } Console.WriteLine((DateTime.Now - StartTime).TotalMilliseconds.ToString()); //result: 2000 ms //TEST 2 - StringBuilder StartTime = DateTime.Now; StringBuilder tSB = new StringBuilder("test string"); for (int i = 0; i < testLength; i++) { tSB.Append(i.ToString()); } Console.WriteLine((DateTime.Now - StartTime).TotalMilliseconds.ToString()); //result: 4 ms Console.ReadLine(); } } 

Résultats:

  • 30'000 itérations

    • Ssortingng - 2000 ms
    • SsortingngBuilder - 4 ms
  • 1000 itérations

    • Ssortingng - 2 ms
    • SsortingngBuilder - 1 ms
  • 500 itérations

    • Ssortingng - 0 ms
    • SsortingngBuilder - 0 ms

Tant que vous pouvez saisir physiquement le nombre de concaténations (a + b + c …), cela ne devrait pas faire une grande différence. N au carré (à N = 10) est un ralentissement de 100X, ce qui ne devrait pas être trop grave.

Le gros problème est quand vous concaténez des centaines de chaînes. À N = 100, vous obtenez un ralentissement de 10000 fois. Ce qui est plutôt mauvais.

Je ne pense pas qu’il y ait une ligne fine entre quand utiliser ou quand ne pas le faire. À moins, bien sûr, que quelqu’un effectue des tests approfondis pour sortir les conditions d’or.

Pour moi, je n’utiliserai pas SsortingngBuilder si je ne fais que concaténer 2 énormes chaînes. S’il y a une boucle avec un nombre indéterminé, je suis susceptible de le faire, même si la boucle peut être un petit nombre.

Une seule concaténation ne vaut pas la peine d’utiliser un constructeur de chaînes. J’ai généralement utilisé 5 concaténations en règle générale.