la meilleure façon d'effacer le contenu de .NET StringBuilder

Je voudrais vous demander ce que vous pensez est le meilleur moyen (dure moins /consomme moins de ressources) pour effacer le contenu afin de le réutiliser un StringBuilder. Imaginez le scénario suivant:

StringBuilder sb = new StringBuilder();
foreach(var whatever in whateverlist)
{
  sb.Append("{0}", whatever);
}

//Perform some stuff with sb

//Clear stringbuilder here

//Populate stringbuilder again to perform more actions
foreach(var whatever2 in whateverlist2)
{
  sb.Append("{0}", whatever2);
}

Et quand compensation StringBuilder je pense à deux possibilités:

sb = new StringBuilder();

sb.Length = 0;

Quel est le meilleur moyen de l'effacer, et pourquoi?

Merci.

EDIT: je ment avec de l'actuel .NET version 3.5.

Pas une réponse, mais intéressant à lire: bobondevelopment.com/2007/06/11/...
Quelle est la raison de ne pas y compris le StringBuilder.Méthode Clear() comme une alternative?
c# 4.0 n'est pas encore sorti, c'est seulement dans la version 4.0. Sur MSDN, il dit: pris en charge dans: 4.
heureusement pour moi que c#4.0 est sorti blogs.msdn.com/somasegar/default.aspx
Je me demande pourquoi Length est accessible en écriture, mais il n'y a pas de lecture/écriture propriété "Text"? En disant sb.Text = ""; semble plus claire que sb.Length = 0;, et un Text bien pourrait aussi aider dans le scénario où l'on aurait autrement-à-dire sb.Length = 0; sb.Append(StuffToStartWith);.
Probablement parce que .Text propriété encourage les gens à accidentellement l'écriture sb.Text = sb.Text + nextString;, en battant le point de l'ensemble de l'aide d'un StringBuilder en premier lieu.
Il serait raisonnable d'exiger que le code de vouloir définir le contenu d'un Set méthode plutôt qu'une propriété, mais si l'on a pris une telle approche, je ne vois pas de raison Length ne devraient pas être traitées de manière adéquate, surtout depuis qu'il y aurait peut être utilise pour les différentes façons de traiter l'allongement et le raccourcissement des scénarios.

InformationsquelleAutor David Espart | 2009-11-10

.net .net-3.5 c#optimization

66

Si vous ne le faites pas dans .NET 2.0 ou 3.5, écrire une méthode d'extension pour faire comme ceci:
```
///<summary>
///    Clears the contents of the string builder.
///</summary>
///<param name="value">
///    The <see cref="StringBuilder"/> to clear.
///</param>
public static void Clear(this StringBuilder value)
{
    value.Length = 0;
    value.Capacity = 0;
}
```
Ensuite, vous pouvez l'effacer comme ceci:
```
someStringBuilder.Clear();
```
Puis, quand 4.0 vient de sortir, vous pouvez troquer votre méthode d'extension en faveur de la version 4.0.

Mise à JOUR: Ce n'est probablement pas une bonne idée de la Capacité de zéro. Qui va garantir les réaffectations lorsque vous ajoutez à la bâtisseur, si vous êtes à la réutilisation de la même instance. Toutefois, la mémoire de l'instance du constructeur n'est pas libéré jusqu'à ce que vous définissez la Capacité à une valeur très faible (1). La valeur par défaut de la propriété de Capacité est de 16 ans. Vous pouvez envisager d'utiliser 16, ou (si c'est moins efficace) réglage de la capacité deux fois:
- 1 ou zéro pour effacer la mémoire
- Mis à votre Capacité d'origine de la valeur (qui peut être différente de 16) à restaurer.
- Neat Méthode. Juste ce que je cherchais.
- Je déconseille de compensation de la capacité, sauf lorsque le StringBuilder est connu pour avoir tenu quelque chose de anormalement big. Surtout dans les versions antérieures de .net, si l'on veut être à plusieurs reprises la construction des chaînes de plus de 42 500 caractères, la compensation de la mémoire tampon après chaque chaîne de causer des objets supplémentaires allouées dans le Tas d'Objets Volumineux à chaque fois que le tampon est à re-pousser. C'est une Mauvaise Chose.
- Réglage de la capacité de 0, est une idée intéressante. Quand il vient à l'aide de Claire ou juste réglage de la longueur de 0, une fuite de mémoire peut se produire lorsque l'Insert() est utilisée à plusieurs reprises, parce que la Capacité ne cesse de croître malgré la Claire. (voir ma question: stackoverflow.com/questions/29574469/...
InformationsquelleAutor Mike Hofer
28

Dans .NET 4.0, vous pouvez appeler sb.Clear() mais en version plus ancienne, vous devez définir sb.Length = 0.

La Clear() méthode a été ajouté dans .NET 4.0.
- Capacité à zéro aussi...
- Si vous êtes à la réutilisation, il ne serait pas vous voulez réutiliser le tampon?
- dépend de la variance de la façon dont beaucoup de grands la chaîne créée la première fois par rapport à la chaîne créée pour la deuxième fois.. Ou au moins je pense que oui
InformationsquelleAutor GraemeF
15

Créer la nouvelle StringBuilder. L'ancien maintient ressources associées (tampon de longueur maximale, par exemple) qui sont les mieux juste les ordures collectées à l'écart.

InformationsquelleAutor Paul Sonier
10

Je pense que vous faites l'optimisation prématurée.

Je serais prêt à parier que faire sb.Length=0; serait le plus rapide pour éviter de créer un autre objet et placer un autre objet de côté pour le GC, éventuellement, de les collecter.

Je pense que la création d'une nouvelle StringBuilder serait le meilleur coup pour soucis de mémoire. et le réglage de sb.Length serait le meilleur coup pour la vitesse préoccupations..

InformationsquelleAutor Earlz
10

De Contenu de la Communauté sur MSDN:
À débarrasser efficacement votre
stringbuilder sans la détruire
utilisation:
```
 someStringBuilder.length = 0;
 someStringBuilder.capacity = 0;
```
Ce qui détruit à la fois de son contenu et
la redimensionne à zéro. Comme indiqué ci-dessus
désactivez la taille peut avoir un impact plus petits
des applications.
InformationsquelleAutor Yuriy Faktorovich

Dans .NET Framework 4 nouvelles méthodes ont été introduites dans StringBuilder classe. Nom de la méthode est "Clair". Cette méthode vous permet de désactiver ou de supprimer des valeurs ou des données à partir de StringBuilder objets.

Ici est un exemple pour cela.

    System.Text.StringBuilder objSB = new System.Text.StringBuilder();
    //Append values
    objSB.Append("This is .Net Blog.");
    objSB.Append("You can get latest C# Tips over here.");

    //Display on screen
    Response.Write(objSB.ToString());
    Response.Write("<br/><br/>");

    //Clear object using Clear method
    objSB.Clear();

    //Append another values
    objSB.Append("This blog is very useful for .Net Beginners");

    Response.Write("After Clear<br/><br/>");
    //Display on screen
    Response.Write(objSB.ToString());

InformationsquelleAutor Jayesh Sorathia

2

Si vous êtes à la recherche pour réduire l'utilisation de la mémoire je voudrais utiliser le CLR Profiler pour vérifier la quantité de mémoire de votre StringBuilder objets à l'aide par le biais de leur cycle de vie en utilisant les méthodes d'autres ont décrit ci-dessus. Ensuite, vous pouvez vous assurer que l'option que vous choisissez est adapté à vos besoins et libère les ressources dont vous avez besoin.

InformationsquelleAutor Kim R
1

Je dirais que le meilleur moyen de l'effacer, il est à utiliser sb = new StringBuilder();. Cela étant dit, je pense que ce serait encore mieux si vous faites un nouveau générateur de chaîne d'objet tout à fait.

MODIFIER

J'espère qu'il va sans dire que c'est la meilleure solution.
```
public StringBuilder MakeString(IEnumerable<CoolType> list)
{
    StringBuilder sb = new StringBuilder();

    foreach(var whatever in list)
    {
        sb.Append("{0}", whatever);
    }
}

var sb = MakeString(whateverList);
//Do stuff
//Clear stuff
sb = MakeString(whateverList2);
```
- sb = new StringBuilder() EST le fait d'une nouvelle chaîne de constructeur de l'objet.
- Faire cela permet de faire un nouveau générateur de chaîne d'objet tout à fait.
- Je pense que Matt signifie déclarer une nouvelle variable POUR la nouvelle StringBuilder.
- Désolé, pour clairify je le recommande de faire quelque chose comme ceci: var wellNamedStringBuilder = new StringBuilder();
InformationsquelleAutor Matt Grande
0

Appelez simplement Clear() méthode de réglage de la longueur = 0 ,
Nous pouvons mettre en Capacité = 0 aussi, si nous voulons économiser de la mémoire
```
public StringBuilder Clear() {
        this.Length = 0;
        return this;
 }
```
Ref: Dans referencesource.microsoft.com

InformationsquelleAutor MaxJ

//P.S. to be ultra efficient 
//make a good guess at the initial allocation too !!!!
int PerWhatever_SizeEstimate = 4; //a guess of average length... you known your data
StringBuilder sb = new StringBuilder( whateverlist.Length * PerWhatever_SizeEstimate);

//reallocation needed? 
//if you want to be efficient speed and memory wise... 
sb.Length = 0;  //rest internal index but don't release/resize memory
//if a ...BIG... difference in size
if( whatever2.Length < whatever.Length * 2/3  
 || whatever2.Length > whatever.Length * 1.5)
{
    //scale capacity appropriately
    sb.Capaciy = sb.Capacity * whatever2.Length / whatever.Length;
}

InformationsquelleAutor PJJ

0

C# En Bref Pour effacer le contenu d'un StringBuilder, il y a deux façons:
1. Ensemble de ses Length à zéro:
  
  Définition d'un StringBuilder est Length à zero n'a pas réduit ses capacités internes. Donc, si le StringBuilder contenait auparavant d'un million de caractères, il continuera d'occuper autour de 2 MO de mémoire après la réinitialisation de sa Longueur.
2. Instancier un nouveau:
  
  Si vous voulez release the memory, vous devez créer un nouveau StringBuilder et de permettre à l'ancien à tomber hors de portée (et le garbage collector), avec cette approche, vous pouvez résoudre l'élément précédent problème.
InformationsquelleAutor Sina Lotfi

Vous devez vous connecter pour publier un commentaire.