Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

StringBuilder, classe

 

Représente une chaîne de caractères mutable. Cette classe ne peut pas être héritée.

Pour parcourir le code source .NET Framework pour ce type, consultez la Reference Source.

Espace de noms:   System.Text
Assembly:  mscorlib (dans mscorlib.dll)

System.Object
  System.Text.StringBuilder

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class StringBuilder : ISerializable

NomDescription
System_CAPS_pubmethodStringBuilder()

Initialise une nouvelle instance de la classe StringBuilder.

System_CAPS_pubmethodStringBuilder(Int32)

Initialise une nouvelle instance de la classe StringBuilder en utilisant la capacité spécifiée.

System_CAPS_pubmethodStringBuilder(Int32, Int32)

Initialise une nouvelle instance de la classe StringBuilder qui commence avec une capacité spécifiée et peut croître jusqu'à un maximum spécifié.

System_CAPS_pubmethodStringBuilder(String)

Initialise une nouvelle instance de la classe StringBuilder à l'aide de la chaîne spécifiée.

System_CAPS_pubmethodStringBuilder(String, Int32)

Initialise une nouvelle instance de la classe StringBuilder en utilisant la chaîne et la capacité spécifiées.

System_CAPS_pubmethodStringBuilder(String, Int32, Int32, Int32)

Initialise une nouvelle instance de la classe StringBuilder à partir de la sous-chaîne et de la capacité spécifiées.

NomDescription
System_CAPS_pubpropertyCapacity

Obtient ou définit le nombre maximal de caractères que peut contenir la mémoire allouée par l'instance actuelle.

System_CAPS_pubpropertyChars[Int32]

Obtient ou définit le caractère situé à la position de caractère spécifiée dans cette instance.

System_CAPS_pubpropertyLength

Obtient ou définit la longueur de l'objet StringBuilder actuel.

System_CAPS_pubpropertyMaxCapacity

Obtient la capacité maximale de cette instance.

NomDescription
System_CAPS_pubmethodAppend(Boolean)

Ajoute à cette instance la représentation sous forme de chaîne d'une valeur booléenne spécifiée.

System_CAPS_pubmethodAppend(Byte)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 8 bits non signé spécifié.

System_CAPS_pubmethodAppend(Char)

Ajoute à cette instance la représentation sous forme de chaîne d’un objet Char spécifié.

System_CAPS_pubmethodAppend(Char*, Int32)

Ajoute à cette instance un tableau de caractères Unicode commençant à une adresse spécifiée.

System_CAPS_pubmethodAppend(Char, Int32)

Ajoute à cette instance un nombre spécifié de copies de la représentation sous forme de chaîne d'un caractère Unicode.

System_CAPS_pubmethodAppend(Char[])

Ajoute à cette instance la représentation sous forme de chaîne des caractères Unicode d'un tableau spécifié.

System_CAPS_pubmethodAppend(Char[], Int32, Int32)

Ajoute à cette instance la représentation sous forme de chaîne d'un sous-tableau spécifié de caractères Unicode.

System_CAPS_pubmethodAppend(Decimal)

Ajoute à cette instance la représentation sous forme de chaîne d'un nombre décimal spécifié.

System_CAPS_pubmethodAppend(Double)

Ajoute à cette instance la représentation sous forme de chaîne d'un nombre à virgule flottante double précision spécifié.

System_CAPS_pubmethodAppend(Int16)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 16 bits signé spécifié.

System_CAPS_pubmethodAppend(Int32)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 32 bits signé spécifié.

System_CAPS_pubmethodAppend(Int64)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 64 bits signé spécifié.

System_CAPS_pubmethodAppend(Object)

Ajoute à cette instance la représentation sous forme de chaîne d'un objet spécifié.

System_CAPS_pubmethodAppend(SByte)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 8 bits signé spécifié.

System_CAPS_pubmethodAppend(Single)

Ajoute à cette instance la représentation sous forme de chaîne d'un nombre à virgule flottante simple précision spécifié.

System_CAPS_pubmethodAppend(String)

Ajoute à cette instance une copie de la chaîne spécifiée.

System_CAPS_pubmethodAppend(String, Int32, Int32)

Ajoute à cette instance une copie d'une sous-chaîne spécifiée.

System_CAPS_pubmethodAppend(UInt16)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 16 bits non signé spécifié.

System_CAPS_pubmethodAppend(UInt32)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 32 bits non signé spécifié.

System_CAPS_pubmethodAppend(UInt64)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 64 bits non signé spécifié.

System_CAPS_pubmethodAppendFormat(IFormatProvider, String, Object)

Ajoute à cette instance la chaîne retournée par le traitement d'une chaîne de format composite, qui contient un nombre supérieur ou égal à zéro d'éléments de mise en forme. Chaque élément de format est remplacé par la représentation sous forme de chaîne d’un argument unique à l’aide d’un fournisseur de format spécifié.

System_CAPS_pubmethodAppendFormat(IFormatProvider, String, Object, Object)

Ajoute à cette instance la chaîne retournée par le traitement d'une chaîne de format composite, qui contient un nombre supérieur ou égal à zéro d'éléments de mise en forme. Chaque élément de format est remplacé par la représentation sous forme de chaîne d'un argument parmi deux à l'aide d'un fournisseur de format spécifié.

System_CAPS_pubmethodAppendFormat(IFormatProvider, String, Object, Object, Object)

Ajoute à cette instance la chaîne retournée par le traitement d'une chaîne de format composite, qui contient un nombre supérieur ou égal à zéro d'éléments de mise en forme. Chaque élément de format est remplacé par la représentation sous forme de chaîne d'un argument parmi trois à l'aide d'un fournisseur de format spécifié.

System_CAPS_pubmethodAppendFormat(IFormatProvider, String, Object[])

Ajoute à cette instance la chaîne retournée par le traitement d'une chaîne de format composite, qui contient un nombre supérieur ou égal à zéro d'éléments de mise en forme. Chaque élément de mise en forme est remplacé par la représentation sous forme de chaîne d'un argument correspondant dans un tableau de paramètres à l'aide d'un fournisseur de format spécifié.

System_CAPS_pubmethodAppendFormat(String, Object)

Ajoute à cette instance la chaîne retournée par le traitement d'une chaîne de format composite, qui contient un nombre supérieur ou égal à zéro d'éléments de mise en forme. Chaque élément de format est remplacé par la représentation sous forme de chaîne d'un argument unique.

System_CAPS_pubmethodAppendFormat(String, Object, Object)

Ajoute à cette instance la chaîne retournée par le traitement d'une chaîne de format composite, qui contient un nombre supérieur ou égal à zéro d'éléments de mise en forme. Chaque élément de format est remplacé par la représentation sous forme de chaîne de l'un des deux arguments possibles.

System_CAPS_pubmethodAppendFormat(String, Object, Object, Object)

Ajoute à cette instance la chaîne retournée par le traitement d'une chaîne de format composite, qui contient un nombre supérieur ou égal à zéro d'éléments de mise en forme. Chaque élément de format est remplacé par la représentation sous forme de chaîne de l'un des trois arguments possibles.

System_CAPS_pubmethodAppendFormat(String, Object[])

Ajoute à cette instance la chaîne retournée par le traitement d'une chaîne de format composite, qui contient un nombre supérieur ou égal à zéro d'éléments de mise en forme. Chaque élément de mise en forme est remplacé par la représentation sous forme de chaîne d'un argument correspondant dans un tableau de paramètres.

System_CAPS_pubmethodAppendLine()

Ajoute la marque de fin de ligne par défaut à la fin de l'objet StringBuilder actuel.

System_CAPS_pubmethodAppendLine(String)

Ajoute une copie de la chaîne spécifiée suivie de la marque de fin de ligne par défaut à la fin de l'objet StringBuilder actuel.

System_CAPS_pubmethodClear()

Supprime tous les caractères de l'instance StringBuilder actuelle.

System_CAPS_pubmethodCopyTo(Int32, Char[], Int32, Int32)

Copie les caractères d'un segment spécifié de cette instance vers un segment spécifié d'un tableau Char de destination.

System_CAPS_pubmethodEnsureCapacity(Int32)

Garantit que la capacité de cette instance de StringBuilder est au moins égale à la valeur spécifiée.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodEquals(StringBuilder)

Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodInsert(Int32, Boolean)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'une valeur booléenne.

System_CAPS_pubmethodInsert(Int32, Byte)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un entier non signé de 8 bits spécifié.

System_CAPS_pubmethodInsert(Int32, Char)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un caractère Unicode spécifié.

System_CAPS_pubmethodInsert(Int32, Char[])

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un tableau de caractères Unicode spécifié.

System_CAPS_pubmethodInsert(Int32, Char[], Int32, Int32)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un sous-tableau de caractères Unicode spécifié.

System_CAPS_pubmethodInsert(Int32, Decimal)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un nombre décimal.

System_CAPS_pubmethodInsert(Int32, Double)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un nombre à virgule flottante double précision.

System_CAPS_pubmethodInsert(Int32, Int16)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un entier signé 16 bits spécifié.

System_CAPS_pubmethodInsert(Int32, Int32)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un entier signé 32 bits spécifié.

System_CAPS_pubmethodInsert(Int32, Int64)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un entier signé de 64 bits.

System_CAPS_pubmethodInsert(Int32, Object)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un objet.

System_CAPS_pubmethodInsert(Int32, SByte)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un entier signé 8 bits spécifié.

System_CAPS_pubmethodInsert(Int32, Single)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un nombre à virgule flottante simple précision.

System_CAPS_pubmethodInsert(Int32, String)

Insère une chaîne dans cette instance, à la position de caractère spécifiée.

System_CAPS_pubmethodInsert(Int32, String, Int32)

Insère dans cette instance une ou plusieurs copies d'une chaîne spécifiée, à la position de caractère spécifiée.

System_CAPS_pubmethodInsert(Int32, UInt16)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un entier non signé 16 bits.

System_CAPS_pubmethodInsert(Int32, UInt32)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un entier non signé 32 bits.

System_CAPS_pubmethodInsert(Int32, UInt64)

Insère dans cette instance, à la position de caractère spécifiée, la représentation sous forme de chaîne d'un entier non signé 64 bits.

System_CAPS_pubmethodRemove(Int32, Int32)

Supprime de cette instance la plage de caractères spécifiée.

System_CAPS_pubmethodReplace(Char, Char)

Remplace toutes les occurrences d'un caractère spécifié dans cette instance par un autre caractère spécifié.

System_CAPS_pubmethodReplace(Char, Char, Int32, Int32)

Remplace toutes les occurrences d'un caractère spécifié dans une sous-chaîne de cette instance par un autre caractère spécifié.

System_CAPS_pubmethodReplace(String, String)

Remplace toutes les occurrences d'une chaîne spécifiée dans cette instance par une autre chaîne spécifiée.

System_CAPS_pubmethodReplace(String, String, Int32, Int32)

Remplace toutes les occurrences d'une chaîne spécifiée dans une sous-chaîne de cette instance par une autre chaîne spécifiée.

System_CAPS_pubmethodToString()

Convertit la valeur de cette instance en String.(Remplace Object.ToString().)

System_CAPS_pubmethodToString(Int32, Int32)

Convertit la valeur d'une sous-chaîne de cette instance en String.

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privmethodISerializable.GetObjectData(SerializationInfo, StreamingContext)

Cette API prend en charge l'infrastructure produit et n'est pas destinée à être utilisée directement à partir de votre code. Remplit un objet System.Runtime.Serialization.SerializationInfo avec les données nécessaires pour désérialiser l'objet StringBuilder actuel.

System_CAPS_noteRemarque

Pour afficher le code source .NET Framework pour ce type, consultez la Reference Source. Vous pouvez parcourir le code source en ligne, télécharger la référence hors connexion et parcourir les sources (y compris les correctifs et mises à jour) pendant le débogage ; see instructions.

Cette classe représente un objet chaîne dont la valeur est une séquence de caractères mutable.

Dans cette section :

Bien que StringBuilder et String représentent des séquences de caractères, elles sont implémentées différemment. String est un type immuable. Autrement dit, chaque opération qui s'affiche pour modifier un String objet crée en fait une nouvelle chaîne.

Par exemple, l'appel à la String.Concat méthode dans l'exemple c# suivant s'affiche pour modifier la valeur d'une variable chaîne nommée value. En fait, la Concat méthode renvoie un value objet qui a une valeur différente et une adresse à partir de la value objet qui a été passé à la méthode. Notez que l'exemple doit être compilé à l'aide de la /unsafe option du compilateur.

using System;

public class Example
{
   public unsafe static void Main()
   {
      string value = "This is the first sentence" + ".";
      fixed (char* start = value)
      {
         value = String.Concat(value, "This is the second sentence. ");
         fixed (char* current = value)
         {
            Console.WriteLine(start == current);
         }
      }   
   }
}
// The example displays the following output:
//      False

Pour les routines qui effectuent la manipulation de chaînes étendues (par exemple, les applications qui modifient une chaîne de plusieurs fois dans une boucle), la modification d'une chaîne à plusieurs reprises peut peser sensiblement les performances. L'alternative consiste à utiliser StringBuilder, qui est une classe de chaîne mutable. Mutabilité signifie qu'une fois qu'une instance de la classe a été créée, elle peut être modifiée par l'ajout, suppression, remplacement ou insertion de caractères. Un StringBuilder objet dispose d'un tampon pour prendre en charge les extensions à la chaîne. Nouvelles données sont ajoutées à la mémoire tampon si l'espace est disponible. Sinon, une mémoire tampon nouvelle est allouée, les données à partir de la mémoire tampon d'origine sont copiées dans la nouvelle mémoire tampon et les nouvelles données sont alors ajoutées à la nouvelle mémoire tampon.

System_CAPS_importantImportant

Bien que la StringBuilder classe offre généralement de meilleures performances que le String (classe), vous ne devez pas remplacer automatiquement String avec StringBuilder chaque fois que vous voulez manipuler des chaînes. Performances dépendent de la taille de la chaîne, la quantité de mémoire à allouer pour la nouvelle chaîne, le système sur lequel votre application s'exécute et le type d'opération. Vous devez être prêt à tester votre application pour déterminer si StringBuilder offre en fait une amélioration significative des performances.

Envisagez d'utiliser la String classe dans ces conditions :

  • Lorsque le nombre de modifications pour rendre votre application en une chaîne est petit. Dans ce cas, StringBuilder peut offre négligeable ou aucune amélioration des performances sur String.

  • Lorsque vous effectuez un nombre fixe d'opérations de concaténation, en particulier avec les littéraux de chaîne. Dans ce cas, le compilateur peut combiner les opérations de concaténation en une seule opération.

  • Lorsque vous devez effectuer des opérations de recherche étendue pendant la création de votre chaîne. Le StringBuilder ne dispose d'aucune classe recherche des méthodes telles que IndexOf ou StartsWith. Vous devrez convertir le StringBuilder de l'objet à un String pour ces opérations et cela peuvent nier l'amélioration des performances de l'utilisation de StringBuilder. Pour plus d'informations, consultez le recherche le texte dans un objet StringBuilder section.

Envisagez d'utiliser la StringBuilder classe dans ces conditions :

  • Si vous pensez que votre application pour apporter un nombre inconnu de modifications à une chaîne au moment du design (par exemple, lorsque vous utilisez une boucle pour concaténer un nombre aléatoire de chaînes qui contiennent des entrées d'utilisateur).

  • Si vous pensez que votre application pour apporter un nombre important de modifications à une chaîne.

Le StringBuilder.Length propriété indique le nombre de caractères du StringBuilder objet contient actuellement. Si vous ajoutez des caractères à la StringBuilder de l'objet, sa longueur augmente jusqu'à ce qu'elle est égale à la taille de la StringBuilder.Capacity propriété, qui définit le nombre de caractères que l'objet peut contenir. Si le nombre de caractères ajoutés provoque la longueur de la StringBuilder objet dépasse sa capacité actuelle, la nouvelle mémoire est allouée, la valeur de la Capacity propriété est doublée, de nouveaux caractères sont ajoutés à la StringBuilder objet et son Length propriété est ajustée. Mémoire supplémentaire pour le StringBuilder objet est alloué dynamiquement jusqu'à ce qu'il atteigne la valeur définie par le StringBuilder.MaxCapacity propriété. Lorsque la capacité maximale est atteinte, aucune mémoire supplémentaire ne pouvant être alloué pour le StringBuilder objet et essayez d'ajouter des caractères ou développer au-delà de sa capacité maximale lève une une ArgumentOutOfRangeException ou un OutOfMemoryException exception.

L'exemple suivant illustre comment un StringBuilder objet alloue de la mémoire et augmente dynamiquement sa capacité développe la chaîne assignée à l'objet. Le code crée un StringBuilder en appelant son constructeur (sans paramètre) par défaut. La capacité par défaut de cet objet est de 16 caractères, et sa capacité maximale est de plus de 2 milliards de caractères. L'ajout de la chaîne « Il s'agit d'une phrase. » génère une nouvelle allocation de mémoire, car la longueur de chaîne (19 caractères) dépasse la capacité par défaut de le StringBuilder objet. Double de la capacité de l'objet à 32 caractères, la nouvelle chaîne est ajoutée et la longueur de l'objet est désormais égal à 19 caractères. Le code ajoute ensuite la chaîne « Il s'agit d'une phrase supplémentaire. » la valeur de la StringBuilder 11 fois de l'objet. Chaque fois que l'opération d'ajout entraîne la longueur de la StringBuilder objet dépasse sa capacité maximale, sa capacité existante est doublé et Append réussit.

using System;
using System.Reflection;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder sb = new StringBuilder();
      ShowSBInfo(sb);
      sb.Append("This is a sentence.");
      ShowSBInfo(sb);
      for (int ctr = 0; ctr <= 10; ctr++) {
         sb.Append("This is an additional sentence.");
         ShowSBInfo(sb);
      }   
   }

   private static void ShowSBInfo(StringBuilder sb)
   {
      foreach (var prop in sb.GetType().GetProperties()) {
         if (prop.GetIndexParameters().Length == 0)
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb));
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Capacity: 16    MaxCapacity: 2,147,483,647    Length: 0
//    Capacity: 32    MaxCapacity: 2,147,483,647    Length: 19
//    Capacity: 64    MaxCapacity: 2,147,483,647    Length: 50
//    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 81
//    Capacity: 128    MaxCapacity: 2,147,483,647    Length: 112
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 143
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 174
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 205
//    Capacity: 256    MaxCapacity: 2,147,483,647    Length: 236
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 267
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 298
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 329
//    Capacity: 512    MaxCapacity: 2,147,483,647    Length: 360

La capacité par défaut d'un StringBuilder objet est de 16 caractères, et sa capacité maximale par défaut est Int32.MaxValue. Ces valeurs par défaut sont utilisées si vous appelez le StringBuilder() et StringBuilder(String) constructeurs.

Vous pouvez définir explicitement la capacité initiale d'un StringBuilder objet comme suit :

  • En appelant une de le StringBuilder constructeurs qui inclut un capacity paramètre lorsque vous créez l'objet.

  • En affectant explicitement une nouvelle valeur pour le StringBuilder.Capacity propriété à développer un existant StringBuilder objet. Notez que la propriété lève une exception si la nouvelle capacité est inférieure à existant supérieur ou égal à la capacité du StringBuilder capacité maximale de l'objet.

  • En appelant le StringBuilder.EnsureCapacity méthode avec la nouvelle capacité. La nouvelle capacité ne doit pas être supérieure à la StringBuilder capacité maximale de l'objet. Toutefois, contrairement à une assignation à la Capacity propriété EnsureCapacity ne lève pas d'exception si la nouvelle capacité de votre choix est inférieur à la capacité existante ; dans ce cas, l'appel de méthode n'a aucun effet.

Si la longueur de la chaîne assignée à la StringBuilder objet dans l'appel de constructeur dépasse la capacité par défaut ou la capacité spécifiée, le Capacity est définie sur la longueur de la chaîne spécifiée avec la value paramètre.

Vous pouvez définir explicitement la capacité maximale d'un StringBuilder en appelant le StringBuilder(Int32, Int32) constructeur. Vous ne pouvez pas modifier la capacité maximale en affectant une nouvelle valeur à la MaxCapacity propriété, car il est en lecture seule.

La section précédente montre, chaque fois que la capacité existante est inadéquate, supplémentaire de la mémoire est allouée et la capacité d'un StringBuilder doubles jusqu'à la valeur définie par l'objet du MaxCapacity propriété.

En général, la capacité par défaut et la capacité maximale sont adaptés à la plupart des applications. Vous pouvez envisager de définir ces valeurs dans les conditions suivantes :

  • Si la taille finale de la StringBuilder objet est susceptible de devenir extrêmement volumineux, en général plus de plusieurs mégaoctets. Dans ce cas, il peut y avoir des gains de performance à partir de la définition de la première Capacity propriété à une valeur pour éliminer la nécessité de réallocation de mémoire trop importante.

  • Si votre application s'exécute sur un système avec une mémoire limitée. Dans ce cas, vous souhaiterez paramètre le MaxCapacity propriété à moins de Int32.MaxValue Si votre application gère les chaînes de grande taille qui peuvent s'exécuter dans un environnement limité en mémoire.

Vous instanciez un StringBuilder objet en appelant une de ses six constructeurs de classe surchargés, qui sont répertoriées dans le tableau suivant. Trois constructeurs instancier un StringBuilder objet dont la valeur est une chaîne vide, mais définir son Capacity et MaxCapacity valeurs différemment. Les trois autres constructeurs définissent un StringBuilder objet qui possède une valeur de chaîne spécifique et la capacité. Deux des trois constructeurs utilisent la capacité maximale par défaut de Int32.MaxValue, tandis que le troisième vous permet de définir la capacité maximale.

Constructeur

Valeur de chaîne

Capacité

Capacité maximale

StringBuilder()

String.Empty

16

Int32.MaxValue

StringBuilder(Int32)

String.Empty

Défini par le capacity paramètre

Int32.MaxValue

StringBuilder(Int32, Int32)

String.Empty

Défini par le capacity paramètre

Défini par le maxCapacity paramètre

StringBuilder(String)

Défini par le value paramètre

16 ou value. Length, plus importante étant retenue

Int32.MaxValue

StringBuilder(String, Int32)

Défini par le value paramètre

Défini par le capacity paramètre ou value. Length, plus importante étant retenue.

Int32.MaxValue

StringBuilder(String, Int32, Int32, Int32)

Défini par value. Substring(startIndex, length)

Défini par le capacity paramètre ou value. Length, plus importante étant retenue.

Défini par le maxCapacity paramètre

L'exemple suivant utilise trois de ces surcharges de constructeur pour instancier StringBuilder objets.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      string value = "An ordinary string";
      int index = value.IndexOf("An ") + 3;
      int capacity = 0xFFFF;

      // Instantiate a StringBuilder from a string.
      StringBuilder sb1 = new StringBuilder(value);
      ShowSBInfo(sb1); 

      // Instantiate a StringBuilder from string and define a capacity.  
      StringBuilder sb2 = new StringBuilder(value, capacity);   
      ShowSBInfo(sb2); 

      // Instantiate a StringBuilder from substring and define a capacity.  
      StringBuilder sb3 = new StringBuilder(value, index, 
                                            value.Length - index, 
                                            capacity );
      ShowSBInfo(sb3); 
   }

   public static void ShowSBInfo(StringBuilder sb)
   {
      Console.WriteLine("\nValue: {0}", sb.ToString());
      foreach (var prop in sb.GetType().GetProperties()) {
         if (prop.GetIndexParameters().Length == 0)
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb));
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Value: An ordinary string
//    Capacity: 18    MaxCapacity: 2,147,483,647    Length: 18
//    
//    Value: An ordinary string
//    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 18
//    
//    Value: ordinary string
//    Capacity: 65,535    MaxCapacity: 2,147,483,647    Length: 15

La plupart des méthodes qui modifient la chaîne dans un StringBuilder instance retournent une référence à cette même instance. Cela vous permet d'appeler StringBuilder méthodes de deux manières :

  • Vous pouvez effectuer des appels de méthode individuelle et ignorer la valeur de retour, comme dans l'exemple suivant.

    using System;
    using System.Text;
    
    public class Example
    {
       public static void Main()
       {
          StringBuilder sb = new StringBuilder();
          sb.Append("This is the beginning of a sentence, ");
          sb.Replace("the beginning of ", "");
          sb.Insert(sb.ToString().IndexOf("a ") + 2, "complete ");
          sb.Replace(",", ".");
          Console.WriteLine(sb.ToString());
       }
    }
    // The example displays the following output:
    //        This is a complete sentence.
    
  • Vous pouvez effectuer une série d'appels de méthode dans une instruction unique. Cela peut être pratique si vous souhaitez écrire une seule instruction qui enchaîne des opérations successives. L'exemple suivant regroupe trois appels de méthode à partir de l'exemple précédent en une seule ligne de code.

    using System;
    using System.Text;
    
    public class Example
    {
       public static void Main()
       {
          StringBuilder sb = new StringBuilder("This is the beginning of a sentence, ");
          sb.Replace("the beginning of ", "").Insert(sb.ToString().IndexOf("a ") + 2, 
                                                     "complete ").Replace(",", ".");
          Console.WriteLine(sb.ToString());
       }
    }
    // The example displays the following output:
    //        This is a complete sentence.
    

Vous pouvez utiliser les méthodes de la StringBuilder classe pour effectuer une itération, ajouter, supprimer ou modifier des caractères dans un StringBuilder objet.

Vous pouvez accéder aux caractères dans un StringBuilder à l'aide de la StringBuilder.Chars propriété. En c#, Chars est un indexeur ; en Visual Basic, il est la propriété par défaut de la StringBuilder classe. Cela vous permet de définir ou extraire des caractères individuels à l'aide de leur index uniquement, sans référencer explicitement le Chars propriété. Caractères dans un StringBuilder objet commence à l'index 0 (zéro) et continue à indexer Length - 1.

L'exemple suivant illustre le Chars propriété. Il ajoute 10 nombres aléatoires à une StringBuilder de l'objet, puis itère au sein de chaque caractère. Si la catégorie du caractère Unicode est UnicodeCategory.DecimalDigitNumber, il réduit le nombre de 1 (ou modifie le nombre à 9 si sa valeur est 0). L'exemple affiche le contenu de la StringBuilder de l'objet à la fois avant et après les valeurs des caractères individuels ont été modifiés.

using System;
using System.Globalization;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();

      // Generate 10 random numbers and store them in a StringBuilder.
      for (int ctr = 0; ctr <= 9; ctr++)
         sb.Append(rnd.Next().ToString("N5"));    

      Console.WriteLine("The original string:");
      Console.WriteLine(sb.ToString());

      // Decrease each number by one.
      for (int ctr = 0; ctr < sb.Length; ctr++) {
         if (Char.GetUnicodeCategory(sb[ctr]) == UnicodeCategory.DecimalDigitNumber) {
            int number = (int) Char.GetNumericValue(sb[ctr]);
            number--;
            if (number < 0) number = 9;

            sb[ctr] = number.ToString()[0];
         }
      }
      Console.WriteLine("\nThe new string:");
      Console.WriteLine(sb.ToString());
   }
}
// The example displays the following output:
//    The original string:
//    1,457,531,530.00000940,522,609.000001,668,113,564.000001,998,992,883.000001,792,660,834.00
//    000101,203,251.000002,051,183,075.000002,066,000,067.000001,643,701,043.000001,702,382,508
//    .00000
//    
//    The new string:
//    0,346,420,429.99999839,411,598.999990,557,002,453.999990,887,881,772.999990,681,559,723.99
//    999090,192,140.999991,940,072,964.999991,955,999,956.999990,532,690,932.999990,691,271,497
//    .99999

La StringBuilder classe comprend les méthodes suivantes pour développer le contenu d'un StringBuilder objet :

  • Le Append méthode ajoute une chaîne, une sous-chaîne, un tableau de caractères, une partie d'un tableau de caractères, un seul caractère répété plusieurs fois, ou le type de la représentation sous forme de chaîne de données primitif à un StringBuilder objet.

  • Le AppendLine méthode ajoute un terminateur de ligne ou une chaîne le long d'un terminateur de ligne dans un StringBuilder objet.

  • Le AppendFormat méthode ajoute un à un StringBuilder objet. Les représentations sous forme de chaîne d'objets inclus dans la chaîne de résultat peuvent refléter les conventions de mise en forme de la culture système actuelle ou la culture spécifiée.

  • Le Insert méthode insère une chaîne, une sous-chaîne, plusieurs répétitions d'une chaîne, un tableau de caractères, une partie d'un tableau de caractères, ou la représentation sous forme de chaîne de données primitif type à une position spécifiée dans le StringBuilder objet. La position est définie par un index de base zéro.

L'exemple suivant utilise le Append, AppendLine, AppendFormat, et Insert méthodes pour développer le texte d'un StringBuilder objet.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      // Create a StringBuilder object with no text.
      StringBuilder sb = new StringBuilder();
      // Append some text.
      sb.Append('*', 10).Append(" Adding Text to a StringBuilder Object ").Append('*', 10);
      sb.AppendLine("\n");
      sb.AppendLine("Some code points and their corresponding characters:");
      // Append some formatted text.
      for (int ctr = 50; ctr <= 60; ctr++) {
         sb.AppendFormat("{0,12:X4} {1,12}", ctr, Convert.ToChar(ctr));
         sb.AppendLine();
      }
      // Find the end of the introduction to the column.
      int pos = sb.ToString().IndexOf("characters:") + 11 + 
                Environment.NewLine.Length;
      // Insert a column header.
      sb.Insert(pos, String.Format("{2}{0,12:X4} {1,12}{2}", "Code Unit", 
                                   "Character", "\n"));      

      // Convert the StringBuilder to a string and display it.      
      Console.WriteLine(sb.ToString());      
   }
}
// The example displays the following output:
//    ********** Adding Text to a StringBuilder Object **********
//    
//    Some code points and their corresponding characters:
//    
//       Code Unit    Character
//            0032            2
//            0033            3
//            0034            4
//            0035            5
//            0036            6
//            0037            7
//            0038            8
//            0039            9
//            003A            :
//            003B            ;
//            003C            <

La StringBuilder classe inclut des méthodes permettant de réduire la taille de l'utilisateur actuel StringBuilder instance. Le Clear méthode supprime tous les caractères et définit le Length propriété à zéro. Le Remove méthode supprime le nombre spécifié de caractères commençant à une position d'index spécifique. En outre, vous pouvez supprimer des caractères à partir de la fin d'une StringBuilder objet en définissant son Length propriété à une valeur inférieure à la longueur de l'instance actuelle.

L'exemple suivant supprime une partie du texte d'un StringBuilder objet affiche sa capacité résultant, la capacité maximale et les valeurs de propriété de longueur et appelle ensuite la Clear méthode pour supprimer tous les caractères de la StringBuilder objet.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder sb = new StringBuilder("A StringBuilder object");
      ShowSBInfo(sb);
      // Remove "object" from the text.
      string textToRemove = "object";
      int pos = sb.ToString().IndexOf(textToRemove);
      if (pos >= 0) {
         sb.Remove(pos, textToRemove.Length);
         ShowSBInfo(sb);
      }
      // Clear the StringBuilder contents.
      sb.Clear();
      ShowSBInfo(sb);   
   }

   public static void ShowSBInfo(StringBuilder sb)
   {
      Console.WriteLine("\nValue: {0}", sb.ToString());
      foreach (var prop in sb.GetType().GetProperties()) {
         if (prop.GetIndexParameters().Length == 0)
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb));
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Value: A StringBuilder object
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 22
//    
//    Value: A StringBuilder
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 16
//    
//    Value:
//    Capacity: 22    MaxCapacity: 2,147,483,647    Length: 0

Le StringBuilder.Replace méthode remplace toutes les occurrences d'un caractère ou une chaîne dans l'ensemble du StringBuilder objet ou dans une plage de caractères particulier. L'exemple suivant utilise le Replace méthode pour remplacer tous les points d'exclamation (!) avec des points d'interrogation (?) dans le StringBuilder objet.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
      MyStringBuilder.Replace('!', '?');
      Console.WriteLine(MyStringBuilder);
   }
}
// The example displays the following output:
//       Hello World?

La StringBuilder classe n'inclut pas de méthodes semblables à la String.Contains, String.IndexOf, et String.StartsWith méthodes fournies par le String (classe), ce qui vous permet de rechercher l'objet pour un caractère particulier ou d'une sous-chaîne. Détermination de la présence ou de caractère de départ d'une sous-chaîne requiert que vous recherchez un String à l'aide d'une méthode de recherche de chaîne ou une méthode d'expression régulière. Il existe quatre façons d'implémenter ces recherches, comme le tableau suivant.

Technique

Professionnels de l'informatique

Inconvénients

Rechercher des valeurs de chaîne avant de les ajouter à la StringBuilder objet.

Utile pour déterminer l'existence d'une sous-chaîne.

Ne peut pas être utilisé lors de la position d'index d'une sous-chaîne est importante.

Appelez ToString et recherche retourné String objet.

Facile à utiliser si vous attribuez à tout le texte à un StringBuilder de l'objet et commencez à le modifier.

Difficile à appeler à plusieurs reprises ToString Si vous devez apporter des modifications avant tout le texte est ajouté à la StringBuilder objet.

Vous devez penser à travailler à partir de la fin de la StringBuilder texte de l'objet si vous apportez des modifications.

Utilisez le Chars propriété recherche séquentiellement dans une plage de caractères.

Utile si vous êtes concerné avec des caractères individuels ou d'une sous-chaîne petit.

Lourde si le nombre de caractères à rechercher est grand ou si la logique de recherche est complexe.

Convertir le StringBuilder de l'objet à un String de l'objet et effectuer des modifications sur le String objet.

Cette option est utile si le nombre de modifications est faible.

Inverse l'amélioration des performances de la StringBuilder classe si le nombre de modifications est grand.

Examinons ces techniques plus en détail.

  • Si l'objectif de la recherche est de déterminer si une sous-chaîne particulière existe (autrement dit, si vous n'êtes pas intéressé par la position de la sous-chaîne), vous pouvez rechercher des chaînes avant de les stocker dans le StringBuilder objet. L'exemple suivant illustre une implémentation possible. Il définit un StringBuilderFinder classe dont le constructeur est passé à un StringBuilder objet et la sous-chaîne à rechercher dans la chaîne. Dans ce cas, l'exemple tente de déterminer si enregistrées températures en degrés Fahrenheit ou en degrés Celsius et ajoute le texte d'introduction approprié au début de la StringBuilder objet. Un générateur de nombres aléatoires est utilisé pour sélectionner un tableau qui contient les données en degrés Celsius ou degrés Fahrenheit.

    using System;
    using System.Text;
    
    public class Example
    {
       public static void Main()
       {
          Random rnd = new Random();
          string[] tempF = { "47.6F", "51.3F", "49.5F", "62.3F" };
          string[] tempC = { "21.2C", "16.1C", "23.5C", "22.9C" };
          string[][] temps = { tempF, tempC }; 
    
          StringBuilder sb = new StringBuilder();
          var f = new StringBuilderFinder(sb, "F");
          var baseDate = new DateTime(2013, 5, 1); 
          String[] temperatures = temps[rnd.Next(2)];
          bool isFahrenheit = false;
          foreach (var temperature in temperatures) {
             if (isFahrenheit)
                sb.AppendFormat("{0:d}: {1}\n", baseDate, temperature);
             else
                isFahrenheit = f.SearchAndAppend(String.Format("{0:d}: {1}\n", 
                                                 baseDate, temperature));
             baseDate = baseDate.AddDays(1);
          }            
          if (isFahrenheit) {
             sb.Insert(0, "Average Daily Temperature in Degrees Fahrenheit");
             sb.Insert(47, "\n\n");
          }
          else {
             sb.Insert(0, "Average Daily Temperature in Degrees Celsius");
             sb.Insert(44, "\n\n");
          }   
          Console.WriteLine(sb.ToString());
       }
    }
    
    public class StringBuilderFinder
    {
       private StringBuilder sb;
       private String text;
    
       public StringBuilderFinder(StringBuilder sb, String textToFind)
       {
          this.sb = sb;
          this.text = textToFind;
       }
    
       public bool SearchAndAppend(String stringToSearch)
       {
          sb.Append(stringToSearch);
          return stringToSearch.Contains(text);
       }
    }
    // The example displays output similar to the following:
    //    Average Daily Temperature in Degrees Celsius
    //    
    //    5/1/2013: 21.2C
    //    5/2/2013: 16.1C
    //    5/3/2013: 23.5C
    //    5/4/2013: 22.9C
    
  • Appelez le StringBuilder.ToString méthode pour convertir le StringBuilder de l'objet à un String objet. Vous pouvez rechercher la chaîne à l'aide de méthodes comme String.LastIndexOf ou String.StartsWith, ou vous pouvez utiliser des expressions régulières et le Regex pour rechercher des modèles de classe. Étant donné que les deux StringBuilder et String objets utilisent l'encodage pour stocker les caractères, les positions d'index de sous-chaînes, caractères UTF-16 et les correspondances d'expression régulière sont identiques dans les deux objets. Cela vous permet d'utiliser StringBuilder méthodes pour apporter des modifications à la même position à laquelle ce texte se trouve dans le String objet.

    System_CAPS_noteRemarque

    Si vous adoptez cette approche, vous devez travailler à partir de la fin de la StringBuilder objet à ses débuts, afin que vous n'êtes pas obligé de convertir de manière répétée la StringBuilder objet en une chaîne.

    L'exemple suivant illustre cette approche. Il stocke quatre occurrences de chaque lettre de l'alphabet anglais dans un StringBuilder objet. Il convertit ensuite le texte à un String de l'objet et utilise une expression régulière pour identifier la position de départ de chaque séquence de quatre caractères. Enfin, il ajoute un trait de soulignement avant chaque séquence de quatre caractères, à l'exception de la première séquence et convertit le premier caractère de la séquence en majuscules.

    using System;
    using System.Text;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          // Create a StringBuilder object with 4 successive occurrences 
          // of each character in the English alphabet. 
          StringBuilder sb = new StringBuilder();
          for (ushort ctr = (ushort)'a'; ctr <= (ushort) 'z'; ctr++)
             sb.Append(Convert.ToChar(ctr), 4);
    
          // Create a parallel string object.
          String sbString = sb.ToString();
          // Determine where each new character sequence begins.
          String pattern = @"(\w)\1+";
          MatchCollection matches = Regex.Matches(sbString, pattern);
    
          // Uppercase the first occurrence of the sequence, and separate it
          // from the previous sequence by an underscore character.
          for (int ctr = matches.Count - 1; ctr >= 0; ctr--) { 
             Match m = matches[ctr];
             sb[m.Index] = Char.ToUpper(sb[m.Index]);
             if (m.Index > 0) sb.Insert(m.Index, "_");
          }
          // Display the resulting string.
          sbString = sb.ToString();
          int line = 0;
          do {
             int nChars = line * 80 + 79 <= sbString.Length ? 
                                 80 : sbString.Length - line * 80;
             Console.WriteLine(sbString.Substring(line * 80, nChars));
             line++;
          } while (line * 80 < sbString.Length);
       }
    }
    // The example displays the following output:
    //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
    //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
    
  • Utilisez le StringBuilder.Chars propriété recherche séquentiellement dans une plage de caractères dans un StringBuilder objet. Cette approche ne peut pas être pratique si le nombre de caractères à rechercher est étendu ou de la logique de recherche est particulièrement complexe.

    L'exemple suivant est identique dans sa fonctionnalité à l'exemple précédent, mais diffère dans l'implémentation. Il utilise le Chars propriété pour détecter la modification d'une valeur de caractère, insère un trait de soulignement à cette position et convertit le premier caractère de la nouvelle séquence de caractères majuscules.

    using System;
    using System.Text;
    
    public class Example
    {
       public static void Main()
       {
          // Create a StringBuilder object with 4 successive occurrences 
          // of each character in the English alphabet. 
          StringBuilder sb = new StringBuilder();
          for (ushort ctr = (ushort) 'a'; ctr <= (ushort) 'z'; ctr++)
             sb.Append(Convert.ToChar(ctr), 4);
    
          // Iterate the text to determine when a new character sequence occurs.
          int position = 0;
          Char current = '\u0000';
          do {
             if (sb[position] != current) {
                current = sb[position];
                sb[position] = Char.ToUpper(sb[position]);
                if (position > 0) 
                   sb.Insert(position, "_");
                position += 2;
             }
             else {
                position++;
             }      
          } while (position <= sb.Length - 1);
          // Display the resulting string.
          String sbString = sb.ToString();
          int line = 0;
          do {
             int nChars = line * 80 + 79 <= sbString.Length ? 
                                 80 : sbString.Length - line * 80;
             Console.WriteLine(sbString.Substring(line * 80, nChars));
             line++;
          } while (line * 80 < sbString.Length);
       }
    }
    // The example displays the following output:
    //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
    //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
    
  • Stocker tout le texte modifié dans le StringBuilder de l'objet, appelez la StringBuilder.ToString méthode pour convertir le StringBuilder de l'objet à un String de l'objet et effectuer les modifications sur le String objet. Vous pouvez utiliser cette approche si vous avez seulement quelques modifications ; Sinon, le coût de l'utilisation de chaînes immuables peut anéantir les avantages de l'utilisation un StringBuilder objet.

    L'exemple suivant est identique dans sa fonctionnalité aux deux exemples précédents, mais diffère dans l'implémentation. Il crée un StringBuilder de l'objet, le convertit en un String de l'objet, puis utilise une expression régulière pour effectuer toutes les modifications restantes sur la chaîne. Le Regex.Replace(String, String, MatchEvaluator) méthode utilise une expression lambda pour effectuer le remplacement de chaque correspondance.

    using System;
    using System.Text;
    using System.Text.RegularExpressions;
    
    public class Example
    {
       public static void Main()
       {
          // Create a StringBuilder object with 4 successive occurrences 
          // of each character in the English alphabet. 
          StringBuilder sb = new StringBuilder();
          for (ushort ctr = (ushort)'a'; ctr <= (ushort) 'z'; ctr++)
             sb.Append(Convert.ToChar(ctr), 4);
    
          // Convert it to a string.
          String sbString = sb.ToString();
    
          // Use a regex to uppercase the first occurrence of the sequence, 
          // and separate it from the previous sequence by an underscore.
          string pattern = @"(\w)(\1+)";
          sbString = Regex.Replace(sbString, pattern, 
                                   m => (m.Index > 0 ? "_" : "") + 
                                   m.Groups[1].Value.ToUpper() + 
                                   m.Groups[2].Value);
    
          // Display the resulting string.
          int line = 0;
          do {
             int nChars = line * 80 + 79 <= sbString.Length ? 
                                 80 : sbString.Length - line * 80;
             Console.WriteLine(sbString.Substring(line * 80, nChars));
             line++;
          } while (line * 80 < sbString.Length);
       }
    }
    // The example displays the following output:
    //    Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_
    //    Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_Zzzz
    

Vous devez convertir le StringBuilder de l'objet à un String avant de pouvoir passer la chaîne représentée par l'objet du StringBuilder objet à une méthode qui a un String paramètre ou pour l'afficher dans l'interface utilisateur. Vous effectuez cette conversion en appelant le StringBuilder.ToString (méthode). Pour obtenir une illustration, consultez l'exemple précédent, qui appelle la ToString méthode pour convertir un StringBuilder de l'objet en chaîne afin qu'elle peut être passée à une méthode d'expression régulière.

Remarques à l'attention des appelants :

Dans le.NET Framework 4 et .NET Framework 4.5, lorsque vous instanciez le StringBuilder en appelant le StringBuilder(Int32, Int32) constructeur, la longueur et la capacité de la StringBuilder instance peut augmenter au-delà de la valeur de son MaxCapacity propriété. Cela peut se produire en particulier lorsque vous appelez le Append et AppendFormat méthodes pour ajouter des chaînes de taille réduite.

L'exemple suivant montre comment appeler la plupart des méthodes définies par le StringBuilder (classe).

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

Universal Windows Platform
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Portable Class Library
Pris en charge dans : portable .NET platforms
Silverlight
Disponible depuis 2.0
Windows Phone Silverlight
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

Tous les membres statiques (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Retour au début
Afficher: