StringBuilder: comment obtenir la dernière chaîne?

Question

Quelqu'un m'a dit qu'il est plus rapide de concaténer des chaînes avec StringBuilder. J'ai changé mon code mais je ne vois aucune propriété ou méthode pour obtenir la chaîne de construction finale.

Comment puis-je obtenir la chaîne?

Answer 1

Vous pouvez utiliser .ToString () pour obtenir le String à partir de StringBuilder .

Answer 2

Lorsque vous dites "il est plus rapide de concaténer une chaîne avec un constructeur de chaînes", cela n'est vrai que si vous êtes à plusieurs reprises (je le répète - à plusieurs reprises ) concaténant même objet.

Si vous ne faites que concaténer 2 chaînes et que vous agissez immédiatement avec le résultat sous la forme d'une chaîne , il n'y a aucun intérêt à utiliser StringBuilder .

Je viens de tomber sur l'écriture intéressante de Jon Skeet: http: // www. yoda.arachsys.com/csharp/stringbuilder.html

Si vous utilisez StringBuilder , pour obtenir la chaîne résultante, il suffit d'appeler ToString () (sans surprise).

Answer 3

Une fois le traitement terminé à l'aide de StringBuilder, utilisez la méthode ToString pour renvoyer le résultat final.

À partir de MSDN:

using System;
using System.Text;

public sealed class App 
{
    static void Main() 
    {
        // Create a StringBuilder that expects to hold 50 characters.
        // Initialize the StringBuilder with "ABC".
        StringBuilder sb = new StringBuilder("ABC", 50);

        // Append three characters (D, E, and F) to the end of the StringBuilder.
        sb.Append(new char[] { 'D', 'E', 'F' });

        // Append a format string to the end of the StringBuilder.
        sb.AppendFormat("GHI{0}{1}", 'J', 'k');

        // Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString());

        // Insert a string at the beginning of the StringBuilder.
        sb.Insert(0, "Alphabet: ");

        // Replace all lowercase k's with uppercase K's.
        sb.Replace('k', 'K');

        // Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString());
    }
}

// This code produces the following output.
//
// 11 chars: ABCDEFGHIJk
// 21 chars: Alphabet: ABCDEFGHIJK

Answer 4

Je voudrais juste dire que ce n’est pas nécessairement plus rapide, cela aura certainement une meilleure empreinte mémoire. En effet, les chaînes sont immuables dans .NET et chaque fois que vous modifiez une chaîne, vous en créez une nouvelle.

Answer 5

Que ce soit plus rapide / meilleure mémoire:

J'ai examiné ce problème avec Java, je suppose. NET serait aussi intelligent à ce sujet.

L'implémentation de String est assez impressionnante.

L'objet String suit " longueur " et " partagé " (indépendant de la longueur du tableau contenant la chaîne)

Donc quelque chose comme

String a = "abc" + "def" + "ghi";

peut être implémenté (par le compilateur / runtime) en tant que:

 - Extend the array holding "abc" by 6 additional spaces.
 - Copy def in right after abc 
 - copy ghi in after def. 
 - give a pointer to the "abc" string to a 
 - leave abc's length at 3, set a's length to 9
 - set the shared flag in both.

La plupart des chaînes étant de courte durée, il en résulte un code TRÈS efficace dans de nombreux cas. Le cas où cela n’EST absolument PAS efficace s’applique lorsque vous ajoutez une chaîne dans une boucle ou lorsque votre code est comme ceci:

a = "abc";
a = a + "def";
a += "ghi";

Dans ce cas, vous feriez mieux d'utiliser une construction StringBuilder.

Ce que je veux dire, c'est que vous devez faire attention lorsque vous optimisez, sauf si vous êtes absolument sûr de savoir ce que vous faites, ET si vous êtes absolument sûr que cela est nécessaire, ET que vous effectuez des tests pour vous assurer que le code optimisé réussit, il suffit de le coder de la manière la plus lisible possible et d’essayer de ne pas penser au compilateur.

J'ai perdu 3 jours à jouer avec les chaînes, à mettre en cache / réutiliser les constructeurs de chaînes et à tester la vitesse avant de consulter le code source de la chaîne et de constater que le compilateur le faisait déjà mieux que ce que je pouvais pour mon cas d'utilisation. Ensuite, j'ai dû expliquer comment je ne savais VRAIMENT pas ce que je faisais, je pensais seulement que je le savais ...

Answer 6

Ce n'est pas plus rapide à concaténer - Comme l'a souligné smaclell, le problème est la chaîne immuable qui force une allocation supplémentaire et une recopie des données existantes.

"a" + "b" + "c" n’est pas plus rapide avec le constructeur de chaînes, mais les concats répétés avec une chaîne intermédiaire deviennent de plus en plus rapides à mesure que le # de concat devient plus grand, comme:

x = "a"; x + = "b"; x + = "c"; ...