Différence entre string et StringBuilder en c #
J'aimerais connaître la différence entre string et StringBuilder et avoir également besoin d'exemples pour comprendre.
Une instance string est immuable. Vous ne pouvez pas le changer après sa création. Toute opération qui semble changer la chaîne renvoie à la place une nouvelle instance:
string foo = "Foo";
// returns a new string instance instead of changing the old one
string bar = foo.Replace('o', 'a');
string baz = foo + "bar"; // ditto here
Les objets immuables ont certaines propriétés Nice, telles qu’elles peuvent être utilisées sur des threads sans craindre de problèmes de synchronisation ou que vous pouvez simplement distribuer vos champs de sauvegarde privés directement sans craindre que quelqu'un modifie des objets qu’ils ne devraient pas modifier (voir Tableaux ou listes mutables, qui doivent souvent être copiés avant de les renvoyer si ce n’est pas souhaité). Mais si elles sont utilisées sans précaution, elles peuvent créer de graves problèmes de performances (comme à peu près n'importe quoi - si vous avez besoin d'un exemple tiré d'un langage qui tire fierté de sa rapidité d'exécution, examinez les fonctions de manipulation des chaînes de C).
Lorsque vous avez besoin d'une chaîne mutable, telle que celle que vous construisez à la pièce ou que vous modifiez, vous aurez besoin d'une StringBuilder, qui est un tampon de caractères que peut modifier . Cela a pour la plupart des conséquences sur les performances. Si vous voulez une chaîne mutable et que vous le fassiez avec une instance normale string, vous finirez par créer et détruire inutilement de nombreux objets, alors qu'une instance StringBuilder elle-même changera, annulant ainsi le besoin de créer de nombreux nouveaux objets.
Exemple simple: Ce qui suit va faire frémir de douleur chez les programmeurs:
string s = string.Empty;
for (i = 0; i < 1000; i++) {
s += i.ToString() + " ";
}
Vous allez créer ici les chaînes 2001, dont 2 000 sont jetées. Le même exemple utilisant StringBuilder:
StringBuilder sb = new StringBuilder();
for (i = 0; i < 1000; i++) {
sb.Append(i);
sb.Append(' ');
}
Cela devrait mettre beaucoup moins de stress sur l'allocateur de mémoire :-)
Il convient toutefois de noter que le compilateur C # est raisonnablement intelligent en ce qui concerne les chaînes. Par exemple, la ligne suivante
string foo = "abc" + "def" + "efg" + "hij";
sera rejoint par le compilateur, ne laissant qu'une seule chaîne au moment de l'exécution. De même, des lignes telles que
string foo = a + b + c + d + e + f;
sera réécrit pour
string foo = string.Concat(a, b, c, d, e, f);
vous n'avez donc pas à payer pour cinq concaténations insensées, ce qui serait une façon naïve de gérer cela. Cela ne vous sauvera pas dans les boucles comme ci-dessus (à moins que le compilateur ne déroule la boucle mais je pense que seul le JIT peut le faire et mieux ne pariez pas là-dessus).
La chaîne est immuable, ce qui signifie que lorsque vous créez une chaîne, vous ne pouvez jamais la changer. Cela créera plutôt une nouvelle chaîne pour stocker la nouvelle valeur, ce qui peut s'avérer inefficace si vous devez modifier beaucoup la valeur d'une variable chaîne.
StringBuilder peut être utilisé pour simuler une chaîne mutable. Il est donc utile lorsque vous devez modifier beaucoup une chaîne.
String vs. StringBuilder
Chaîne
- Sous Espace de noms système
- Instance immuable (en lecture seule)
Les performances se dégradent lorsqu'un changement de valeur continu se produit
Fil-safe
StringBuilder (chaîne mutable)
- Sous Espace de noms System.Text
- Instance mutable
- Affiche de meilleures performances depuis que de nouvelles modifications sont apportées à une instance existante
Pour un article descriptif sur ce sujet avec de nombreux exemples utilisant ObjectIDGenerator , suivez ce lien .
Question relative au dépassement de capacité de la pile: Mutabilité de chaîne lorsque la chaîne ne change pas en C #
Chaîne
Une instance de chaîne est immuable, c'est-à-dire que nous ne pouvons pas la modifier après sa création. Si nous effectuons une opération sur une chaîne, elle renverra une nouvelle instance (créera une nouvelle instance en mémoire) au lieu de modifier la valeur de l'instance existante.
StringBuilder
StringBuilder est modifiable, c'est-à-dire que si nous effectuons une opération sur StringBuilder, il mettra à jour la valeur de l'instance existante sans créer de nouvelle instance.
StringBuilder vous aidera lorsque vous aurez besoin de créer des chaînes en plusieurs étapes.
Au lieu de faire ceci:
String x = "";
x += "first ";
x += "second ";
x += "third ";
tu fais
StringBuilder sb = new StringBuilder("");
sb.Append("first ");
sb.Append("second ");
sb.Append("third");
String x = sb.ToString();
L'effet final est le même, mais StringBuilder utilisera moins de mémoire et s'exécutera plus rapidement. Au lieu de créer une nouvelle chaîne qui est la concaténation des deux, il créera les morceaux séparément et uniquement à la fin, il les réunira.
Dans la documentation de la classe StringBuilder :
L'objet String est immuable. Chaque fois que vous utilisez l'une des méthodes de la classe System.String, vous créez un nouvel objet chaîne en mémoire, ce qui nécessite une nouvelle allocation d'espace pour ce nouvel objet. Dans les cas où vous devez effectuer des modifications répétées sur une chaîne, la surcharge associée à la création d'un nouvel objet String peut être coûteuse. La classe System.Text.StringBuilder peut être utilisée lorsque vous souhaitez modifier une chaîne sans créer un nouvel objet. Par exemple, l'utilisation de la classe StringBuilder peut améliorer les performances lors de la concaténation de plusieurs chaînes dans une boucle.
Différence majeure:
String est immuable. Cela signifie que vous ne pouvez pas modifier une chaîne du tout; le résultat de la modification est une nouvelle chaîne. Ce n'est pas efficace si vous envisagez d'ajouter à une chaîne.
StringBuilder est modifiable. Il peut être modifié de n'importe quelle manière et ne nécessite pas la création d'une nouvelle instance. Lorsque le travail est terminé, ToString () peut être appelé pour obtenir la chaîne.
Les chaînes peuvent participer à l'internat. Cela signifie que les chaînes avec le même contenu peuvent avoir les mêmes adresses. StringBuilder ne peut pas être interné.
String est la seule classe pouvant avoir un littéral de référence.
Les chaînes sont immuables. Si vous modifiez leur valeur, l'ancienne valeur sera ignorée et une nouvelle valeur sera créée sur le tas, alors que dans le constructeur de chaînes, nous pouvons modifier la valeur existante sans que la nouvelle valeur soit créée.
En termes de performances, String Builder est donc bénéfique, car nous n'occupons inutilement pas plus d'espace mémoire.
System.String est un objet mutable, ce qui signifie qu'il ne peut pas être modifié après sa création. Veuillez vous référer à Différence entre string et StringBuilder en C #? pour une meilleure compréhension.
Une chaîne est un type immuable. Cela signifie que chaque fois que vous commencez à concaténer des chaînes, vous créez de nouvelles chaînes à chaque fois. Si vous le faites tant de fois, vous vous retrouvez avec beaucoup de surcharge de mémoire et le risque de manquer de mémoire.
Une occurrence de StringBuilder permet d’ajouter des chaînes à la même instance, en créant une chaîne lorsque vous appelez la méthode ToString.
En raison de la surcharge liée à l'instanciation d'un objet StringBuilder, Microsoft déclare qu'il est utile de l'utiliser lorsque vous avez plus de 5 à 10 concaténations de chaînes.
Pour un exemple de code, je vous suggère de regarder ici:
Une chaîne (System.String) est un type défini dans le framework .NET. La classe String n'est pas mutable. Cela signifie que chaque fois que vous exécutez une action sur une instance de System.String, le compilateur .NET crée une nouvelle instance de la chaîne. Cette opération est masquée pour le développeur.
Un System.Text.StringBuilder est une classe qui représente une chaîne mutable. Cette classe fournit des méthodes utiles permettant à l'utilisateur de gérer la chaîne enveloppée par StringBuilder. Notez que toutes les manipulations sont effectuées sur la même instance de StringBuilder.
Microsoft encourage l'utilisation de StringBuilder, car il est plus efficace en termes d'utilisation de la mémoire.
La complexité des concaténations de String est également O (N2), tandis que pour StringBuffer, elle est O (N).
Il peut donc y avoir un problème de performances lorsque nous utilisons des concaténations dans des boucles car de nombreux nouveaux objets sont créés à chaque fois.
Vous pouvez utiliser la méthode Clone si vous souhaitez parcourir les chaînes en même temps que le constructeur de chaînes ... Elle renvoie un objet afin que vous puissiez convertir en chaîne à l'aide de la méthode ToString ... :)