StringBuilder Classe

Définition

Espace de noms:

System.Text

Assembly:

System.Runtime.dll

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

public ref class StringBuilder sealed : System::Runtime::Serialization::ISerializable

public sealed class StringBuilder : System.Runtime.Serialization.ISerializable

type StringBuilder = class
    interface ISerializable

Public NotInheritable Class StringBuilder
Implements ISerializable

Héritage

Object

StringBuilder

Implémente

ISerializable

Exemples

L’exemple suivant montre comment appeler de nombreuses méthodes définies par la StringBuilder classe .

using namespace System;
using namespace System::Text;

int main()
{
    // Create a StringBuilder that expects to hold 50 characters.
    // Initialize the StringBuilder with "ABC".
    StringBuilder^ sb = gcnew StringBuilder("ABC", 50);

    // Append three characters (D, E, and F) to the end of the
    // StringBuilder.
    sb->Append(gcnew array<Char>{'D', 'E', 'F'});

    // Append a format string to the end of the StringBuilder.
    sb->AppendFormat("GHI{0}{1}", (Char)'J', (Char)'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

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

open System.Text

// Create a StringBuilder that expects to hold 50 characters.
// Initialize the StringBuilder with "ABC".
let sb = StringBuilder("ABC", 50)

// Append three characters (D, E, and F) to the end of the StringBuilder.
sb.Append [| 'D'; 'E'; 'F' |] |> ignore

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

// Display the number of characters in the StringBuilder and its string.
printfn $"{sb.Length} chars: {sb}"

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

// Replace all lowercase k's with uppercase K's.
sb.Replace('k', 'K') |> ignore

// Display the number of characters in the StringBuilder and its string.
printfn $"{sb.Length} chars: {sb}"

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

Imports System.Text

Public Module App 
    Public Sub Main() 
        ' Create a StringBuilder that expects to hold 50 characters.
        ' Initialize the StringBuilder with "ABC".
        Dim sb As New StringBuilder("ABC", 50)

        ' Append three characters (D, E, and F) to the end of the StringBuilder.
        sb.Append(New Char() {"D"c, "E"c, "F"c})

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

        ' 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())
    End Sub
End Module

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

Remarques

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

Dans cette section :

• Types String et StringBuilder

• Fonctionnement de StringBuilder

• Allocation de mémoire

• Instanciation d’un objet StringBuilder

• Appel de méthodes StringBuilder

• Exécution d’opérations StringBuilder

  • Itération des caractères StringBuilder

  • Ajout de texte à un objet StringBuilder

  • Suppression de texte d’un objet StringBuilder

  • Modification du texte dans un objet StringBuilder

• Recherche du texte dans un objet StringBuilder

• Conversion de l’objet StringBuilder en chaîne

Types String et StringBuilder

Bien que StringBuilder et String les deux représentent des séquences de caractères, ils sont implémentés différemment. String est un type immuable. Autrement dit, chaque opération qui semble modifier un String objet crée une chaîne.

Par exemple, l’appel à la String.Concat méthode dans l’exemple C# suivant semble modifier la valeur d’une variable de chaîne nommée value. En fait, la Concat méthode retourne un value objet qui a une valeur et une adresse différentes de l’objet value qui a été passé à la méthode. Notez que l’exemple doit être compilé à l’aide de l’option du /unsafe 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

    let mutable value = "This is the first sentence" + "."
    use start = fixed value
    value <- System.String.Concat(value, "This is the second sentence. ")
    use current = fixed value
    printfn $"{start = current}"
// The example displays the following output:
//      False

Pour les routines qui effectuent une manipulation de chaîne étendue (par exemple, les applications qui modifient une chaîne plusieurs fois dans une boucle), la modification répétée d’une chaîne peut entraîner une pénalité de performances importante. L’alternative consiste à utiliser StringBuilder, qui est une classe de chaîne mutable. La mutabilité signifie qu’une fois qu’une instance de la classe a été créée, elle peut être modifiée en ajoutant, en supprimant, en remplaçant ou en insérant des caractères. Un StringBuilder objet conserve une mémoire tampon pour prendre en charge les extensions de la chaîne. Les nouvelles données sont ajoutées à la mémoire tampon si la salle est disponible ; sinon, une nouvelle mémoire tampon plus grande est allouée, les données de la mémoire tampon d’origine sont copiées dans la nouvelle mémoire tampon et les nouvelles données sont ensuite ajoutées à la nouvelle mémoire tampon.

Important

Bien que la StringBuilder classe offre généralement de meilleures performances que la String classe, vous ne devez pas remplacer String automatiquement par StringBuilder chaque fois que vous souhaitez manipuler des chaînes. Les performances dépendent de la taille de la chaîne, de la quantité de mémoire à allouer pour la nouvelle chaîne, du système sur lequel votre code s’exécute et du type d’opération. Vous devez être prêt à tester votre code pour déterminer s’il StringBuilder offre réellement une amélioration significative des performances.

Envisagez d’utiliser la String classe dans ces conditions :

• Lorsque le nombre de modifications apportées par votre code à une chaîne est faible. Dans ce cas, StringBuilder peut offrir une amélioration des performances négligeable ou nulle par rapport à String.

• Lorsque vous effectuez un nombre fixe d’opérations de concaténation, en particulier avec des 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 étendues pendant que vous générez votre chaîne. La StringBuilder classe ne dispose pas de méthodes de recherche telles que IndexOf ou StartsWith. Vous devez convertir l’objet StringBuilder en un String pour ces opérations, ce qui peut nier l’avantage de performances de l’utilisation StringBuilderde . Pour plus d’informations, consultez la section Recherche de texte dans un objet StringBuilder .

Envisagez d’utiliser la StringBuilder classe dans ces conditions :

• Lorsque vous vous attendez à ce que votre code apporte un nombre inconnu de modifications à une chaîne au moment de la conception (par exemple, lorsque vous utilisez une boucle pour concaténer un nombre aléatoire de chaînes qui contiennent une entrée utilisateur).

• Lorsque vous vous attendez à ce que votre code apporte un nombre significatif de modifications à une chaîne.

Fonctionnement de StringBuilder

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

L’exemple suivant montre comment un StringBuilder objet alloue une nouvelle mémoire et augmente sa capacité dynamiquement à mesure que la chaîne affectée à l’objet se développe. Le code crée un StringBuilder objet en appelant son constructeur par défaut (sans paramètre). 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 ». entraîne une nouvelle allocation de mémoire, car la longueur de chaîne (19 caractères) dépasse la capacité par défaut de l’objet StringBuilder . La capacité de l’objet double à 32 caractères, la nouvelle chaîne est ajoutée et la longueur de l’objet est désormais égale à 19 caractères. Le code ajoute ensuite la chaîne « Il s’agit d’une phrase supplémentaire » à la valeur de l’objet StringBuilder 11 fois. Chaque fois que l’opération d’ajout entraîne le dépassement de la longueur de l’objet StringBuilder , sa capacité existante est doublée et l’opération 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

open System.Text

let showSBInfo (sb: StringBuilder) =
    for prop in sb.GetType().GetProperties() do
        if prop.GetIndexParameters().Length = 0 then
            printf $"{prop.Name}: {prop.GetValue sb:N0}    "

    printfn ""

let sb = StringBuilder()
showSBInfo sb
sb.Append "This is a sentence." |> ignore
showSBInfo sb

for i = 0 to 10 do
    sb.Append "This is an additional sentence." |> ignore
    showSBInfo sb

// 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

Imports System.Reflection
Imports System.Text

Module Example
   Public Sub Main()
      Dim sb As New StringBuilder()
      ShowSBInfo(sb)
      sb.Append("This is a sentence.")
      ShowSbInfo(sb)
      For ctr As Integer = 0 To 10
         sb.Append("This is an additional sentence.")
         ShowSbInfo(sb)
      Next   
   End Sub
   
   Public Sub ShowSBInfo(sb As StringBuilder)
      For Each prop In sb.GetType().GetProperties
         If prop.GetIndexParameters().Length = 0 Then
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb))
         End If   
      Next
      Console.WriteLine()
   End Sub
End Module
' 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

Allocation de mémoire

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 les StringBuilder() constructeurs et StringBuilder(String) .

Vous pouvez définir explicitement la capacité initiale d’un StringBuilder objet des manières suivantes :

• En appelant l’un StringBuilder des constructeurs qui inclut un capacity paramètre lorsque vous créez l’objet.

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

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

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

Vous pouvez définir explicitement la capacité maximale d’un StringBuilder objet 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 elle est en lecture seule.

Comme le montre la section précédente, chaque fois que la capacité existante est insuffisante, une mémoire supplémentaire est allouée et la capacité d’un StringBuilder objet double jusqu’à la valeur définie par la MaxCapacity propriété.

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

• Si la taille finale de l’objet StringBuilder est susceptible de croître excessivement, généralement au-delà de plusieurs mégaoctets. Dans ce cas, il peut y avoir un avantage en matière de performances à définir la propriété initiale Capacity sur une valeur significativement élevée pour éliminer le besoin de réallocations de mémoire trop nombreuses.

• Si votre code s’exécute sur un système avec une mémoire limitée. Dans ce cas, vous pouvez envisager de définir la MaxCapacity propriété sur moins que Int32.MaxValue si votre code gère des chaînes volumineuses qui peuvent l’entraîner à s’exécuter dans un environnement de mémoire limitée.

Instanciation d’un objet StringBuilder

Vous instanciez un StringBuilder objet en appelant l’un de ses six constructeurs de classes surchargés, qui sont répertoriés dans le tableau suivant. Trois des constructeurs instancient un StringBuilder objet dont la valeur est une chaîne vide, mais définissent ses Capacity valeurs et MaxCapacity différemment. Les trois constructeurs restants définissent un StringBuilder objet qui a une valeur de chaîne et une capacité spécifiques. 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, selon la valeur la plus élevée	Int32.MaxValue
StringBuilder(String, Int32)	Défini par le value paramètre	Défini par le capacity paramètre ou value. Length, selon la valeur la plus élevée.	Int32.MaxValue
StringBuilder(String, Int32, Int32, Int32)	défini par value. Substring(startIndex, length)	Défini par le capacity paramètre ou value. Length, selon la valeur la plus élevée.	Int32.MaxValue

L’exemple suivant utilise trois de ces surcharges de constructeur pour instancier des 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

open System.Text

let showSBInfo (sb: StringBuilder) =
    for prop in sb.GetType().GetProperties() do
        if prop.GetIndexParameters().Length = 0 then
            printf $"{prop.Name}: {prop.GetValue sb:N0}    "

    printfn ""

let value = "An ordinary string"
let index = value.IndexOf "An " + 3
let capacity = 0xFFFF

// Instantiate a StringBuilder from a string.
let sb1 = StringBuilder value
showSBInfo sb1

// Instantiate a StringBuilder from string and define a capacity.
let sb2 = StringBuilder(value, capacity)
showSBInfo sb2

// Instantiate a StringBuilder from substring and define a capacity.
let sb3 = StringBuilder(value, index, value.Length - index, capacity)
showSBInfo sb3

// 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

Imports System.Text

Module Example
   Public Sub Main()
      Dim value As String = "An ordinary string"
      Dim index As Integer = value.IndexOf("An ") + 3
      Dim capacity As Integer = &hFFFF
      
      ' Instantiate a StringBuilder from a string.
      Dim sb1 As New StringBuilder(value)
      ShowSBInfo(sb1) 
      
      ' Instantiate a StringBuilder from string and define a capacity.  
      Dim sb2 As New StringBuilder(value, capacity)   
      ShowSBInfo(sb2) 
      
      ' Instantiate a StringBuilder from substring and define a capacity.  
      Dim sb3 As New StringBuilder(value, index, 
                                   value.Length - index, 
                                   capacity )
      ShowSBInfo(sb3) 
   End Sub
   
   Public Sub ShowSBInfo(sb As StringBuilder)
      Console.WriteLine()
      Console.WriteLine("Value: {0}", sb.ToString())
      For Each prop In sb.GetType().GetProperties
         If prop.GetIndexParameters().Length = 0 Then
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb))
         End If   
      Next
      Console.WriteLine()
   End Sub
End Module
' 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

Appel de méthodes StringBuilder

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

• Vous pouvez effectuer des appels de méthode individuels et ignorer la valeur de retour, comme le fait 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.
  

  open System.Text
  
  let sb = StringBuilder()
  sb.Append "This is the beginning of a sentence, " |> ignore
  sb.Replace("the beginning of ", "") |> ignore
  sb.Insert((string sb).IndexOf "a " + 2, "complete ") |> ignore
  sb.Replace(",", ".") |> ignore
  printfn $"{sb}"
  // The example displays the following output:
  //        This is a complete sentence.
  

  Imports System.Text
  
  Module Example
     Public Sub Main()
        Dim sb As 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())
     End Sub
  End Module
  ' The example displays the following output:
  '       This is a complete sentence.
  

• Vous pouvez effectuer une série d’appels de méthode dans une seule instruction. Cela peut être pratique si vous souhaitez écrire une seule instruction qui chaîne les opérations successives. L’exemple suivant regroupe trois appels de méthode 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.
  

  open System.Text
  
  let sb = StringBuilder "This is the beginning of a sentence, "
  
  sb
      .Replace("the beginning of ", "")
      .Insert((string sb).IndexOf "a " + 2, "complete ")
      .Replace(",", ".")
  |> ignore
  
  printfn $"{sb}"
  // The example displays the following output:
  //        This is a complete sentence.
  

  Imports System.Text
  
  Module Example
     Public Sub Main()
        Dim sb As 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())
     End Sub
  End Module
  ' The example displays the following output:
  '       This is a complete sentence.
  

Exécution d’opérations StringBuilder

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

Itération des caractères StringBuilder

Vous pouvez accéder aux caractères d’un StringBuilder objet à l’aide de la StringBuilder.Chars[] propriété . En C#, Chars[] est un indexeur ; en Visual Basic, il s’agit de la propriété par défaut de la StringBuilder classe . Cela vous permet de définir ou de récupérer des caractères individuels à l’aide de leur index uniquement, sans référencer explicitement la Chars[] propriété. Les caractères d’un StringBuilder objet commencent à l’index 0 (zéro) et continuent à indexer Length - 1.

L’exemple suivant illustre la Chars[] propriété . Il ajoute dix nombres aléatoires à un StringBuilder objet, puis itère chaque caractère. Si la catégorie Unicode du caractère est UnicodeCategory.DecimalDigitNumber, elle diminue le nombre de 1 (ou remplace le nombre par 9 si sa valeur est 0). L’exemple montre comment afficher le contenu de l’objet StringBuilder avant et après la modification des valeurs des caractères individuels.

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

open System
open System.Globalization
open System.Text

let rnd = Random()
let sb = new StringBuilder()

// Generate 10 random numbers and store them in a StringBuilder.
for _ = 0 to 9 do
    rnd.Next().ToString "N5" |> sb.Append |> ignore

printfn "The original string:"
printfn $"{sb}"

// Decrease each number by one.
for i = 0 to sb.Length - 1 do
    if Char.GetUnicodeCategory(sb[i]) = UnicodeCategory.DecimalDigitNumber then
        let number = Char.GetNumericValue sb.[i] |> int
        let number = number - 1
        let number = if number < 0 then 9 else number
        sb.[i] <- number.ToString()[0]

printfn "\nThe new string:"
printfn $"{sb}"

// 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

Imports System.Globalization
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim sb As New StringBuilder()
      
      ' Generate 10 random numbers and store them in a StringBuilder.
      For ctr As Integer = 0 To 9
         sb.Append(rnd.Next().ToString("N5"))    
      Next
      Console.WriteLine("The original string:")
      Console.WriteLine(sb.ToString())
      Console.WriteLine()
            
      ' Decrease each number by one.
      For ctr As Integer = 0 To sb.Length - 1
         If Char.GetUnicodeCategory(sb(ctr)) = UnicodeCategory.DecimalDigitNumber Then
            Dim number As Integer = CType(Char.GetNumericValue(sb(ctr)), Integer)
            number -= 1
            If number < 0 Then number = 9
         
            sb(ctr) = number.ToString()(0)
         End If
      Next
      Console.WriteLine("The new string:")
      Console.WriteLine(sb.ToString())
   End Sub
End Module
' 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

L’utilisation de l’indexation basée sur des caractères avec la propriété Chars[] peut être très lente dans les conditions suivantes :

• L’instance de StringBuilder est grande (par exemple, elle est constituée de plusieurs dizaines de milliers de caractères).
• est StringBuilder « segmenté ». Autrement dit, les appels répétés à des méthodes telles que StringBuilder.Append ont automatiquement développé la propriété de StringBuilder.Capacity l’objet et lui ont alloué de nouveaux blocs de mémoire.

Les performances sont gravement affectées, car chaque accès aux caractères doit parcourir toute la liste chaînée des blocs pour trouver la mémoire tampon correcte où indexer.

Notes

Même pour un grand objet « segmenté », StringBuilder l’utilisation de la Chars[] propriété pour l’accès basé sur un index à un ou un petit nombre de caractères a un impact négligeable sur les performances ; en général, il s’agit d’une opération O(n). Un impact significatif sur les performances se produit par contre lors de l’itération dans les caractères contenus dans l’objet StringBuilder, qui est une opération O(n^2).

Si vous rencontrez des problèmes de performances lors de l’utilisation de l’indexation basée sur des caractères avec des objets StringBuilder, vous pouvez utiliser une des solutions de contournement suivantes :

• Convertissez l’instance de StringBuilder en String en appelant la méthode ToString, puis accédez aux caractères de la chaîne.

• Copiez le contenu de l’objet StringBuilder existant dans un objet StringBuilder prédimensionné. Les performances s’améliorent, car le nouvel objet StringBuilder ne contient pas de gros blocs. Exemple :

  // sbOriginal is the existing StringBuilder object
  var sbNew = new StringBuilder(sbOriginal.ToString(), sbOriginal.Length);
  

  ' sbOriginal is the existing StringBuilder object
  Dim sbNew = New StringBuilder(sbOriginal.ToString(), sbOriginal.Length)
  

• Définissez la capacité initiale de l’objet StringBuilder à une valeur approximativement égale à sa taille maximale attendue en appelant le constructeur StringBuilder(Int32). Notez que ceci alloue l’intégralité du bloc de mémoire, même si StringBuilder atteint rarement sa capacité maximale.

Ajout de texte à un objet StringBuilder

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

• La 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 caractère unique répété plusieurs fois ou la représentation sous forme de chaîne d’un type de données primitif à un StringBuilder objet.

• La AppendLine méthode ajoute un terminateur de ligne ou une chaîne ainsi qu’un terminateur de ligne à un StringBuilder objet .

• La AppendFormat méthode ajoute une chaîne de format composite à 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 d’une culture spécifiée.

• La 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 d’un type de données primitif à une position spécifiée dans l’objet StringBuilder . La position est définie par un index de base zéro.

L’exemple suivant utilise les Appendméthodes , AppendLine, AppendFormatet Insert 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            <

open System
open System.Text

// Create a StringBuilder object with no text.
let sb = StringBuilder()
// Append some text.
sb
    .Append('*', 10)
    .Append(" Adding Text to a StringBuilder Object ")
    .Append('*', 10)
|> ignore

sb.AppendLine "\n" |> ignore
sb.AppendLine "Some code points and their corresponding characters:" |> ignore
// Append some formatted text.
for i = 50 to 60 do
    sb.AppendFormat("{0,12:X4} {1,12}", i, Convert.ToChar i) |> ignore
    sb.AppendLine() |> ignore

// Find the end of the introduction to the column.
let pos = (string sb).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"))
|> ignore

// Convert the StringBuilder to a string and display it.
printfn $"{sb}"


// 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            <

Imports System.Text

Module Example
   Public Sub Main()
      ' Create a StringBuilder object with no text.
      Dim sb As New StringBuilder()
      ' Append some text.
      sb.Append("*"c, 10).Append(" Adding Text to a StringBuilder Object ").Append("*"c, 10)
      sb.AppendLine()
      sb.AppendLine()
      sb.AppendLine("Some code points and their corresponding characters:")
      ' Append some formatted text.
      For ctr = 50 To 60
         sb.AppendFormat("{0,12:X4} {1,12}", ctr, Convert.ToChar(ctr))
         sb.AppendLine()
      Next
      ' Find the end of the introduction to the column.
      Dim pos As Integer = 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", vbCrLf))      

      ' Convert the StringBuilder to a string and display it.      
      Console.WriteLine(sb.ToString())      
   End Sub
End Module
' 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            <

Suppression de texte d’un objet StringBuilder

La StringBuilder classe inclut des méthodes qui peuvent réduire la taille de l’instance actuelle StringBuilder . La Clear méthode supprime tous les caractères et définit la Length propriété sur zéro. La Remove méthode supprime un nombre spécifié de caractères commençant à une position d’index particulière. En outre, vous pouvez supprimer des caractères de la fin d’un StringBuilder objet en affectant à sa 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 ses valeurs de propriété de capacité, de capacité maximale et de longueur résultantes, puis appelle la Clear méthode pour supprimer tous les caractères de l’objet StringBuilder .

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

open System.Text

let showSBInfo (sb: StringBuilder) =
    for prop in sb.GetType().GetProperties() do
        if prop.GetIndexParameters().Length = 0 then
            printf $"{prop.Name}: {prop.GetValue sb:N0}    "

    printfn ""

let sb = StringBuilder "A StringBuilder object"
showSBInfo sb
// Remove "object" from the text.
let textToRemove = "object"
let pos = (string sb).IndexOf textToRemove

if pos >= 0 then
    sb.Remove(pos, textToRemove.Length) |> ignore
    showSBInfo sb

// Clear the StringBuilder contents.
sb.Clear() |> ignore
showSBInfo sb

// 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

Imports System.Text

Module Example
   Public Sub Main()
      Dim sb As New StringBuilder("A StringBuilder object")
      ShowSBInfo(sb)
      ' Remove "object" from the text.
      Dim textToRemove As String = "object"
      Dim pos As Integer = sb.ToString().IndexOf(textToRemove)
      If pos >= 0
         sb.Remove(pos, textToRemove.Length)
         ShowSBInfo(sb)
      End If
      ' Clear the StringBuilder contents.
      sb.Clear()
      ShowSBInfo(sb)   
   End Sub

   Public Sub ShowSBInfo(sb As StringBuilder)
      Console.WriteLine()
      Console.WriteLine("Value: {0}", sb.ToString())
      For Each prop In sb.GetType().GetProperties
         If prop.GetIndexParameters().Length = 0 Then
            Console.Write("{0}: {1:N0}    ", prop.Name, prop.GetValue(sb))
         End If   
      Next
      Console.WriteLine()
   End Sub
End Module
' 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

Modification du texte dans un objet StringBuilder

La StringBuilder.Replace méthode remplace toutes les occurrences d’un caractère ou d’une chaîne dans l’objet entier StringBuilder ou dans une plage de caractères particulière. L’exemple suivant utilise la Replace méthode pour remplacer tous les points d’exclamation (!) par des points d’interrogation (?) dans l’objet StringBuilder .

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?

open System.Text

let myStringBuilder = StringBuilder "Hello World!"
myStringBuilder.Replace('!', '?') |> ignore
printfn $"{myStringBuilder}"

// The example displays the following output:
//       Hello World?

Imports System.Text

Module Example
   Public Sub Main()
      Dim MyStringBuilder As New StringBuilder("Hello World!")
      MyStringBuilder.Replace("!"c, "?"c)
      Console.WriteLine(MyStringBuilder)
   End Sub
End Module
' The example displays the following output:
'       Hello World?

Recherche de texte dans un objet StringBuilder

La StringBuilder classe n’inclut pas de méthodes similaires aux String.Containsméthodes , String.IndexOfet String.StartsWith fournies par la String classe , qui vous permettent de rechercher un caractère particulier ou une sous-chaîne dans l’objet. Pour déterminer la présence ou la position du caractère de départ d’une sous-chaîne, vous devez rechercher une String valeur à l’aide d’une méthode de recherche de chaîne ou d’une méthode d’expression régulière. Il existe quatre façons d’implémenter ces recherches, comme le montre le tableau suivant.

Technique	Avantages	Inconvénients
Recherchez des valeurs de chaîne avant de les ajouter à l’objet StringBuilder .	Utile pour déterminer si une sous-chaîne existe.	Impossible d’utiliser lorsque la position d’index d’une sous-chaîne est importante.
Appelez et recherchez ToString l’objet retourné String .	Facile à utiliser si vous affectez tout le texte à un StringBuilder objet, puis commencez à le modifier.	Fastidieux à appeler ToString à plusieurs reprises si vous devez apporter des modifications avant que tout le texte soit ajouté à l’objet StringBuilder . Vous devez vous rappeler de travailler à partir de la fin du texte de l’objet StringBuilder si vous apportez des modifications.
Utilisez la Chars[] propriété pour effectuer une recherche séquentielle dans une plage de caractères.	Utile si vous vous préoccupez de caractères individuels ou d’une petite sous-chaîne.	Fastidieux si le nombre de caractères à rechercher est élevé ou si la logique de recherche est complexe. Entraîne des performances très médiocres pour les objets qui sont devenus très volumineux grâce à des appels de méthode répétés.
Convertissez l’objet StringBuilder en objet String et effectuez des modifications sur l’objet String .	Utile si le nombre de modifications est faible.	Annule l’avantage en matière de performances de la StringBuilder classe si le nombre de modifications est important.

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 l’objet StringBuilder . L’exemple suivant fournit une implémentation possible. Elle définit une StringBuilderFinder classe dont le constructeur est passé une référence à un StringBuilder objet et la sous-chaîne à rechercher dans la chaîne. Dans ce cas, l’exemple tente de déterminer si les températures enregistrées sont en Fahrenheit ou Celsius, et ajoute le texte d’introduction approprié au début de l’objet StringBuilder . Un générateur de nombres aléatoires est utilisé pour sélectionner un tableau qui contient des données en degrés Celsius ou en 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
  

  open System
  open System.Text
  
  type StringBuilderFinder(sb: StringBuilder, textToFind: string) =
      member _.SearchAndAppend(stringToSearch: string) =
          sb.Append stringToSearch |> ignore
          stringToSearch.Contains textToFind
  
  let tempF = [| "47.6F"; "51.3F"; "49.5F"; "62.3F" |]
  let tempC = [| "21.2C"; "16.1C"; "23.5C"; "22.9C" |]
  let temps = [| tempF; tempC |]
  
  let sb = StringBuilder()
  let f = StringBuilderFinder(sb, "F")
  let temperatures = temps[Random.Shared.Next(2)]
  let mutable baseDate = DateTime(2013, 5, 1)
  let mutable isFahrenheit = false
  
  for temperature in temperatures do
      if isFahrenheit then
          sb.AppendFormat("{0:d}: {1}\n", baseDate, temperature) |> ignore
      else
          isFahrenheit <- $"{baseDate:d}: {temperature}\n" |> f.SearchAndAppend
  
      baseDate <- baseDate.AddDays 1
  
  if isFahrenheit then
      sb.Insert(0, "Average Daily Temperature in Degrees Fahrenheit") |> ignore
      sb.Insert(47, "\n\n") |> ignore
  
  else
      sb.Insert(0, "Average Daily Temperature in Degrees Celsius") |> ignore
      sb.Insert(44, "\n\n") |> ignore
  
  printfn $"{sb}"
  
  // 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
  

  Imports System.Text
  
  Module Example
     Public Sub Main()
        Dim rnd As New Random()
        Dim tempF() As String = { "47.6F", "51.3F", "49.5F", "62.3F" }
        Dim tempC() As String = { "21.2C", "16.1C", "23.5C", "22.9C" }
        Dim temps()() As String = { tempF, tempC } 
  
        Dim sb As StringBuilder = New StringBuilder()
        Dim f As New StringBuilderFinder(sb, "F")
        Dim baseDate As New DateTime(2013, 5, 1) 
        Dim temperatures() As String = temps(rnd.Next(2))
        Dim isFahrenheit As Boolean = False
        For Each temperature In temperatures
           If isFahrenheit Then
              sb.AppendFormat("{0:d}: {1}{2}", baseDate, temperature, vbCrLf)
           Else
              isFahrenheit = f.SearchAndAppend(String.Format("{0:d}: {1}{2}", 
                                               baseDate, temperature, vbCrLf))
           End If
           baseDate = baseDate.AddDays(1)
        Next            
        If isFahrenheit Then
           sb.Insert(0, "Average Daily Temperature in Degrees Fahrenheit")
           sb.Insert(47, vbCrLf + vbCrLf)
        Else
           sb.Insert(0, "Average Daily Temperature in Degrees Celsius")
           sb.Insert(44, vbCrLf + vbCrLf)
        End If   
        Console.WriteLine(sb.ToString())
     End Sub
  End Module
  
  Public Class StringBuilderFinder
     Private sb As StringBuilder
     Private text As String
     
     Public Sub New(sb As StringBuilder, textToFind As String)
        Me.sb = sb
        text = textToFind
     End Sub
     
     Public Function SearchAndAppend(stringToSearch As String) As Boolean
        sb.Append(stringToSearch)
        Return stringToSearch.Contains(text)
     End Function
  End Class
  ' 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 la StringBuilder.ToString méthode pour convertir l’objet StringBuilder en objet String . Vous pouvez rechercher la chaîne à l’aide de méthodes telles que String.LastIndexOf ou String.StartsWith, ou vous pouvez utiliser des expressions régulières et la Regex classe pour rechercher des modèles. Étant donné que les StringBuilder objets et String utilisent l’encodage UTF-16 pour stocker des caractères, les positions d’index des caractères, des sous-chaînes et des correspondances d’expression régulière sont les mêmes dans les deux objets. Cela vous permet d’utiliser StringBuilder des méthodes pour apporter des modifications à la même position que celle à laquelle ce texte se trouve dans l’objet String .

  Notes

  Si vous adoptez cette approche, vous devez travailler de la fin de l’objet StringBuilder jusqu’au début afin de ne pas avoir à convertir l’objet à plusieurs reprises en StringBuilder 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 en objet String 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
  

  open System
  open System.Text
  open System.Text.RegularExpressions
  
  // Create a StringBuilder object with 4 successive occurrences
  // of each character in the English alphabet.
  let sb = StringBuilder()
  
  for char in 'a' .. 'z' do
      sb.Append(char, 4) |> ignore
  
  // Create a parallel string object.
  let sbString = string sb
  // Determine where each new character sequence begins.
  let pattern = @"(\w)\1+"
  let matches = Regex.Matches(sbString, pattern)
  
  // Uppercase the first occurrence of the sequence, and separate it
  // from the previous sequence by an underscore character.
  for i = matches.Count - 1 downto 0 do
      let m = matches[i]
      sb[m.Index] <- Char.ToUpper sb[m.Index]
  
      if m.Index > 0 then
          sb.Insert(m.Index, "_") |> ignore
  
  // Display the resulting string.
  let sbString2 = string sb
  
  for line = 0 to (sbString2.Length - 1) / 80 do
      let nChars =
          if line * 80 + 79 <= sbString2.Length then
              80
          else
              sbString2.Length - line * 80
  
      printfn $"{sbString2.Substring(line * 80, nChars)}"
  
  
  // 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
  

  Imports System.Text
  Imports System.Text.RegularExpressions
  
  Module Example
     Public Sub Main()
        ' Create a StringBuilder object with 4 successive occurrences 
        ' of each character in the English alphabet. 
        Dim sb As New StringBuilder()
        For ctr As UShort = AscW("a") To Ascw("z")
           sb.Append(ChrW(ctr), 4)
        Next    
        ' Create a parallel string object.
        Dim sbString As String = sb.ToString()
        ' Determine where each new character sequence begins.
        Dim pattern As String = "(\w)\1+"
        Dim matches As MatchCollection = Regex.Matches(sbString, pattern)
  
        ' Uppercase the first occurrence of the sequence, and separate it
        ' from the previous sequence by an underscore character.
        For ctr As Integer = matches.Count - 1 To 0 Step -1 
           Dim m As Match = matches(ctr)
           sb.Chars(m.Index) = Char.ToUpper(sb.Chars(m.index))
           If m.Index > 0 Then sb.Insert(m.Index, "_")
        Next
        ' Display the resulting string.
        sbString = sb.ToString()
        Dim line As Integer = 0
        Do
           Dim nChars As Integer = If(line * 80 + 79 <= sbString.Length, 
                                      80, sbString.Length - line * 80)
           Console.WriteLine(sbString.Substring(line * 80, nChars))
           line += 1
        Loop While line * 80 < sbString.Length
     End Sub
  End Module
  ' 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 la StringBuilder.Chars[] propriété pour effectuer une recherche séquentielle dans une plage de caractères dans un StringBuilder objet . Cette approche peut ne pas être pratique si le nombre de caractères à rechercher est élevé ou si la logique de recherche est particulièrement complexe. Pour connaître les implications en termes de performances de l’accès basé sur l’index caractère par caractère pour les objets très volumineux et segmentés StringBuilder , consultez la documentation de la StringBuilder.Chars[] propriété .

  L’exemple suivant est identique en termes de fonctionnalité à l’exemple précédent, mais diffère dans l’implémentation. Il utilise la Chars[] propriété pour détecter quand une valeur de caractère a changé, insère un trait de soulignement à cette position et convertit le premier caractère de la nouvelle séquence en 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
  

  open System
  open System.Text
  
  // Create a StringBuilder object with 4 successive occurrences
  // of each character in the English alphabet.
  let sb = StringBuilder()
  
  for char in 'a' .. 'z' do
      sb.Append(char, 4) |> ignore
  
  // Iterate the text to determine when a new character sequence occurs.
  let mutable position = 0
  let mutable current = '\u0000'
  
  while position <= sb.Length - 1 do
      if sb[position] <> current then
          current <- sb[position]
          sb[position] <- Char.ToUpper sb[position]
  
          if position > 0 then
              sb.Insert(position, "_") |> ignore
  
          position <- position + 2
  
      else
          position <- position + 1
  
  // Display the resulting string.
  let sbString = string sb
  
  for line = 0 to (sbString.Length - 1) / 80 do
      let nChars =
          if line * 80 + 79 <= sbString.Length then
              80
          else
              sbString.Length - line * 80
  
      printfn $"{sbString.Substring(line * 80, nChars)}"
  
  // 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
  

  Imports System.Text
  
  Module Example
     Public Sub Main()
        ' Create a StringBuilder object with 4 successive occurrences 
        ' of each character in the English alphabet. 
        Dim sb As New StringBuilder()
        For ctr As UShort = AscW("a") To Ascw("z")
           sb.Append(ChrW(ctr), 4)
        Next    
        ' Iterate the text to determine when a new character sequence occurs.
        Dim position As Integer = 0
        Dim current As Char = ChrW(0)
        Do
           If sb(position) <> current Then
              current = sb(position)
              sb(position) = Char.ToUpper(sb(position))
              If position > 0 Then sb.Insert(position, "_")
              position += 2
           Else
              position += 1
           End If      
        Loop While position <= sb.Length - 1
        ' Display the resulting string.
        Dim sbString As String = sb.ToString()
        Dim line As Integer = 0
        Do
           Dim nChars As Integer = If(line * 80 + 79 <= sbString.Length, 
                                      80, sbString.Length - line * 80)
           Console.WriteLine(sbString.Substring(line * 80, nChars))
           line += 1
        Loop While line * 80 < sbString.Length
     End Sub
  End Module
  ' 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
  

• Stockez tout le texte non modifié dans l’objet StringBuilder , appelez la StringBuilder.ToString méthode pour convertir l’objet StringBuilder en objet String et effectuez les modifications sur l’objet String . Vous pouvez utiliser cette approche si vous n’avez que quelques modifications ; sinon, le coût de l’utilisation de chaînes immuables peut annuler les avantages en matière de performances de l’utilisation d’un StringBuilder objet.

  L’exemple suivant est identique en termes de fonctionnalités aux deux exemples précédents, mais diffère dans l’implémentation. Il crée un StringBuilder objet, le convertit en objet String , puis utilise une expression régulière pour effectuer toutes les modifications restantes sur la chaîne. La Regex.Replace(String, String, MatchEvaluator) méthode utilise une expression lambda pour effectuer le remplacement sur 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
  

  open System.Text
  open System.Text.RegularExpressions
  
  // Create a StringBuilder object with 4 successive occurrences
  // of each character in the English alphabet.
  let sb = StringBuilder()
  
  for char in 'a' .. 'z' do
      sb.Append(char, 4) |> ignore
  
  // Convert it to a string.
  let sbString = string sb
  
  // Use a regex to uppercase the first occurrence of the sequence,
  // and separate it from the previous sequence by an underscore.
  let pattern = @"(\w)(\1+)"
  
  let sbStringReplaced =
      Regex.Replace(
          sbString,
          pattern,
          fun m ->
              (if m.Index > 0 then "_" else "")
              + m.Groups[ 1 ].Value.ToUpper()
              + m.Groups[2].Value
      )
  
  // Display the resulting string.
  for line = 0 to (sbStringReplaced.Length - 1) / 80 do
      let nChars =
          if line * 80 + 79 <= sbStringReplaced.Length then
              80
          else
              sbStringReplaced.Length - line * 80
  
      printfn $"{sbStringReplaced.Substring(line * 80, nChars)}"
  
  // 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
  

  Imports System.Text
  Imports System.Text.RegularExpressions
  
  Module Example
     Public Sub Main()
        ' Create a StringBuilder object with 4 successive occurrences 
        ' of each character in the English alphabet. 
        Dim sb As New StringBuilder()
        For ctr As UShort = AscW("a") To Ascw("z")
           sb.Append(ChrW(ctr), 4)
        Next    
        ' Convert it to a string.
        Dim sbString As String = sb.ToString()
  
        ' Use a regex to uppercase the first occurrence of the sequence, 
        ' and separate it from the previous sequence by an underscore.
        Dim pattern As String = "(\w)(\1+)"
        sbString = Regex.Replace(sbString, pattern, 
                                 Function(m) If(m.Index > 0,"_","") + 
                                             m.Groups(1).Value.ToUpper + 
                                             m.Groups(2).Value)
  
        ' Display the resulting string.
        Dim line As Integer = 0
        Do
           Dim nChars As Integer = If(line * 80 + 79 <= sbString.Length, 
                                      80, sbString.Length - line * 80)
           Console.WriteLine(sbString.Substring(line * 80, nChars))
           line += 1
        Loop While line * 80 < sbString.Length
     End Sub
  End Module
  ' 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
  

Conversion de l’objet StringBuilder en chaîne

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

Notes pour les appelants

Dans .NET Core et dans .NET Framework 4.0 et versions ultérieures, lorsque vous instanciez l’objet StringBuilder en appelant le StringBuilder(Int32, Int32) constructeur, la longueur et la capacité de l’instance StringBuilder peuvent dépasser la valeur de sa MaxCapacity propriété. Cela peut se produire en particulier lorsque vous appelez les Append(String) méthodes et AppendFormat(String, Object) pour ajouter de petites chaînes.

Constructeurs

StringBuilder()	Initialise une nouvelle instance de la classe StringBuilder.
StringBuilder(Int32)	Initialise une nouvelle instance de la classe StringBuilder en utilisant la capacité spécifiée.
StringBuilder(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é.
StringBuilder(String)	Initialise une nouvelle instance de la classe StringBuilder à l'aide de la chaîne spécifiée.
StringBuilder(String, Int32)	Initialise une nouvelle instance de la classe StringBuilder en utilisant la chaîne et la capacité spécifiées.
StringBuilder(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.

Propriétés

Capacity	Obtient ou définit le nombre maximal de caractères que peut contenir la mémoire allouée par l'instance actuelle.
Chars[Int32]	Obtient ou définit le caractère situé à la position de caractère spécifiée dans cette instance.
Length	Obtient ou définit la longueur de l'objet StringBuilder actuel.
MaxCapacity	Obtient la capacité maximale de cette instance.

Méthodes

Append(Boolean)	Ajoute à cette instance la représentation sous forme de chaîne d'une valeur booléenne spécifiée.
Append(Byte)	Ajoute à cette instance la représentation sous forme de chaîne d'un entier 8 bits non signé spécifié.
Append(Char)	Ajoute à cette instance la représentation sous forme de chaîne d’un objet Char spécifié.
Append(Char*, Int32)	Ajoute à cette instance un tableau de caractères Unicode commençant à une adresse spécifiée.
Append(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.
Append(Char[])	Ajoute à cette instance la représentation sous forme de chaîne des caractères Unicode d'un tableau spécifié.
Append(Char[], Int32, Int32)	Ajoute à cette instance la représentation sous forme de chaîne d'un sous-tableau spécifié de caractères Unicode.
Append(Decimal)	Ajoute à cette instance la représentation sous forme de chaîne d'un nombre décimal spécifié.
Append(Double)	Ajoute à cette instance la représentation sous forme de chaîne d'un nombre à virgule flottante double précision spécifié.
Append(IFormatProvider, StringBuilder+AppendInterpolatedStringHandler)	Ajoute la chaîne interpolée spécifiée à cette instance à l’aide du format spécifié.
Append(Int16)	Ajoute à cette instance la représentation sous forme de chaîne d'un entier 16 bits signé spécifié.
Append(Int32)	Ajoute à cette instance la représentation sous forme de chaîne d'un entier 32 bits signé spécifié.
Append(Int64)	Ajoute à cette instance la représentation sous forme de chaîne d'un entier 64 bits signé spécifié.
Append(Object)	Ajoute à cette instance la représentation sous forme de chaîne d'un objet spécifié.
Append(ReadOnlyMemory<Char>)	Ajoute à cette instance la représentation sous forme de chaîne d’une région de mémoire de caractères en lecture seule spécifiée.
Append(ReadOnlySpan<Char>)	Ajoute à cette instance la représentation sous forme de chaîne d’une étendue de caractères en lecture seule spécifiée.
Append(SByte)	Ajoute à cette instance la représentation sous forme de chaîne d'un entier 8 bits signé spécifié.
Append(Single)	Ajoute à cette instance la représentation sous forme de chaîne d'un nombre à virgule flottante simple précision spécifié.
Append(String)	Ajoute à cette instance une copie de la chaîne spécifiée.
Append(String, Int32, Int32)	Ajoute à cette instance une copie d'une sous-chaîne spécifiée.
Append(StringBuilder)	Ajoute à cette instance la représentation sous forme de chaîne d’un générateur de chaînes spécifié.
Append(StringBuilder, Int32, Int32)	Ajoute à cette instance une copie d’une sous-chaîne du générateur de chaînes spécifié.
Append(StringBuilder+AppendInterpolatedStringHandler)	Ajoute la chaîne interpolée spécifiée à cette instance.
Append(UInt16)	Ajoute à cette instance la représentation sous forme de chaîne d'un entier 16 bits non signé spécifié.
Append(UInt32)	Ajoute à cette instance la représentation sous forme de chaîne d'un entier 32 bits non signé spécifié.
Append(UInt64)	Ajoute à cette instance la représentation sous forme de chaîne d'un entier 64 bits non signé spécifié.
AppendFormat(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é.
AppendFormat(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é.
AppendFormat(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é.
AppendFormat(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é.
AppendFormat(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.
AppendFormat(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.
AppendFormat(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.
AppendFormat(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.
AppendJoin(Char, Object[])	Concatène les représentations sous forme de chaîne des éléments dans le tableau d’objets fourni, en utilisant le séparateur de caractères spécifié entre chaque membre, puis ajoute le résultat à l’instance actuelle du générateur de chaînes.
AppendJoin(Char, String[])	Concatène les chaînes du tableau fourni en utilisant le séparateur de caractères spécifié entre chaque chaîne, puis ajoute le résultat à l’instance actuelle du générateur de chaînes.
AppendJoin(String, Object[])	Concatène les représentations sous forme de chaîne des éléments dans le tableau d’objets fourni, en utilisant le séparateur spécifié entre chaque membre, puis ajoute le résultat à l’instance actuelle du générateur de chaînes.
AppendJoin(String, String[])	Concatène les chaînes du tableau fourni en utilisant le séparateur spécifié entre chaque chaîne, puis ajoute le résultat à l’instance actuelle du générateur de chaînes.
AppendJoin<T>(Char, IEnumerable<T>)	Concatène et ajoute les membres d’une collection en utilisant le séparateur de caractères spécifié entre chaque membre.
AppendJoin<T>(String, IEnumerable<T>)	Concatène et ajoute les membres d’une collection en utilisant le séparateur spécifié entre chaque membre.
AppendLine()	Ajoute la marque de fin de ligne par défaut à la fin de l'objet StringBuilder actuel.
AppendLine(IFormatProvider, StringBuilder+AppendInterpolatedStringHandler)	Ajoute la chaîne interpolée spécifiée au format spécifié, suivie de la fin de ligne par défaut, à la fin de l’objet StringBuilder actuel.
AppendLine(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.
AppendLine(StringBuilder+AppendInterpolatedStringHandler)	Ajoute la chaîne interpolée spécifiée, suivie du point de terminaison de ligne par défaut à la fin de l’objet StringBuilder actuel.
Clear()	Supprime tous les caractères de l'instance StringBuilder actuelle.
CopyTo(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.
CopyTo(Int32, Span<Char>, Int32)	Copie les caractères d'un segment spécifié de cette instance dans une plage Char de destination.
EnsureCapacity(Int32)	Garantit que la capacité de cette instance de StringBuilder est au moins égale à la valeur spécifiée.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
Equals(ReadOnlySpan<Char>)	Renvoie une valeur indiquant si les caractères de cette instance sont égaux à ceux d'une plage spécifiée de caractères en lecture seule.
Equals(StringBuilder)	Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.
GetChunks()	Retourne un objet qui peut être utilisé pour itérer au sein des blocs de caractères représentés dans un ReadOnlyMemory<Char> créé à partir de cette instance StringBuilder.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
Insert(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.
Insert(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é.
Insert(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é.
Insert(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é.
Insert(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é.
Insert(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.
Insert(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.
Insert(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é.
Insert(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é.
Insert(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.
Insert(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.
Insert(Int32, ReadOnlySpan<Char>)	Insère la séquence de caractères dans cette instance, à la position de caractère spécifiée.
Insert(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é.
Insert(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.
Insert(Int32, String)	Insère une chaîne dans cette instance, à la position de caractère spécifiée.
Insert(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.
Insert(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.
Insert(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.
Insert(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.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Remove(Int32, Int32)	Supprime de cette instance la plage de caractères spécifiée.
Replace(Char, Char)	Remplace toutes les occurrences d'un caractère spécifié dans cette instance par un autre caractère spécifié.
Replace(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é.
Replace(String, String)	Remplace toutes les occurrences d'une chaîne spécifiée dans cette instance par une autre chaîne spécifiée.
Replace(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.
ToString()	Convertit la valeur de cette instance en String.
ToString(Int32, Int32)	Convertit la valeur d'une sous-chaîne de cette instance en String.

Implémentations d’interfaces explicites

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Remplit un objet SerializationInfo avec les données nécessaires pour désérialiser l'objet StringBuilder actuel.

Voir aussi

• String