StringBuilder StringBuilder StringBuilder StringBuilder Class

Définition

Représente une chaîne de caractères mutable.Represents a mutable string of characters. Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class StringBuilder sealed : System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class StringBuilder : System.Runtime.Serialization.ISerializable
type StringBuilder = class
    interface ISerializable
Public NotInheritable Class StringBuilder
Implements ISerializable
Héritage
StringBuilderStringBuilderStringBuilderStringBuilder
Attributs
Implémente

Exemples

L’exemple suivant montre comment appeler la plupart des méthodes définies par la StringBuilder classe.The following example shows how to call many of the methods defined by the StringBuilder class.

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
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 de caractères mutable.This class represents a string-like object whose value is a mutable sequence of characters.

Dans cette section :In this section:

Types String et StringBuilderThe String and StringBuilder types

Bien StringBuilder que String et les deux représentent des séquences de caractères, elles sont implémentées différemment.Although StringBuilder and String both represent sequences of characters, they are implemented differently. Stringest un type immuable.String is an immutable type. Autrement dit, chaque opération qui semble modifier un String objet crée en fait une nouvelle chaîne.That is, each operation that appears to modify a String object actually creates a new string.

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.For example, the call to the String.Concat method in the following C# example appears to change the value of a string variable named value. En fait, la Concat méthode retourne un value objet qui a une valeur et une adresse différentes de value l’objet qui a été passé à la méthode.In fact, the Concat method returns a value object that has a different value and address from the value object that was passed to the method. Notez que l’exemple doit être compilé à l' /unsafe aide de l’option du compilateur.Note that the example must be compiled using the /unsafe compiler option.

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 des manipulations de chaînes étendues (telles que les applications qui modifient une chaîne à plusieurs reprises dans une boucle), la modification répétée d’une chaîne peut avoir un impact significatif sur les performances.For routines that perform extensive string manipulation (such as apps that modify a string numerous times in a loop), modifying a string repeatedly can exact a significant performance penalty. L’alternative consiste à utiliser StringBuilder, qui est une classe de chaîne mutable.The alternative is to use StringBuilder, which is a mutable string class. La mutabilité signifie qu’une fois qu’une instance de la classe a été créée, elle peut être modifiée par l’ajout, la suppression, le remplacement ou l’insertion de caractères.Mutability means that once an instance of the class has been created, it can be modified by appending, removing, replacing, or inserting characters. Un StringBuilder objet gère une mémoire tampon pour prendre en charge les expansions de la chaîne.A StringBuilder object maintains a buffer to accommodate expansions to the string. Les nouvelles données sont ajoutées à la mémoire tampon si l’espace est disponible; dans le cas contraire, 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.New data is appended to the buffer if room is available; otherwise, a new, larger buffer is allocated, data from the original buffer is copied to the new buffer, and the new data is then appended to the new buffer.

Important

Bien que StringBuilder la classe offre généralement de meilleures performances String que la classe, vous ne devez String pas StringBuilder remplacer automatiquement par chaque fois que vous souhaitez manipuler des chaînes.Although the StringBuilder class generally offers better performance than the String class, you should not automatically replace String with StringBuilder whenever you want to manipulate strings. 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 application s’exécute et du type d’opération.Performance depends on the size of the string, the amount of memory to be allocated for the new string, the system on which your app is executing, and the type of operation. Vous devez être prêt à tester votre application pour déterminer si StringBuilder elle offre en fait une amélioration significative des performances.You should be prepared to test your app to determine whether StringBuilder actually offers a significant performance improvement.

Envisagez String d’utiliser la classe dans les conditions suivantes:Consider using the String class under these conditions:

  • Lorsque le nombre de modifications apportées par votre application à une chaîne est faible.When the number of changes that your app will make to a string is small. Dans ces cas- StringBuilder là, peut offrir une Stringamélioration négligeable ou sans aucune amélioration des performances.In these cases, StringBuilder might offer negligible or no performance improvement over String.

  • Lorsque vous effectuez un nombre fixe d’opérations de concaténation, en particulier avec des littéraux de chaîne.When you are performing a fixed number of concatenation operations, particularly with string literals. Dans ce cas, le compilateur peut combiner les opérations de concaténation en une seule opération.In this case, the compiler might combine the concatenation operations into a single operation.

  • Lorsque vous devez effectuer des opérations de recherche étendues pendant que vous générez votre chaîne.When you have to perform extensive search operations while you are building your string. La StringBuilder classe n’a pas de méthodes de IndexOf recherche StartsWithtelles que ou.The StringBuilder class lacks search methods such as IndexOf or StartsWith. Vous devez convertir l' StringBuilder objet String en pour ces opérations, ce qui peut rendre l’avantage de l’utilisation StringBuilderde la performance inversée.You'll have to convert the StringBuilder object to a String for these operations, and this can negate the performance benefit from using StringBuilder. Pour plus d’informations, consultez la section recherche dans le texte dans un objet StringBuilder .For more information, see the Searching the text in a StringBuilder object section.

Envisagez StringBuilder d’utiliser la classe dans les conditions suivantes:Consider using the StringBuilder class under these conditions:

  • Lorsque vous vous attendez à ce que votre application fasse 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 des entrées d’utilisateur).When you expect your app to make an unknown number of changes to a string at design time (for example, when you are using a loop to concatenate a random number of strings that contain user input).

  • Lorsque vous vous attendez à ce que votre application apporte un nombre important de modifications à une chaîne.When you expect your app to make a significant number of changes to a string.

Fonctionnement de StringBuilderHow StringBuilder works

La StringBuilder.Length propriété indique le nombre de caractères que StringBuilder l’objet contient actuellement.The StringBuilder.Length property indicates the number of characters the StringBuilder object currently contains. Si vous ajoutez des caractères à StringBuilder l’objet, sa longueur augmente jusqu’à ce qu’il soit égal StringBuilder.Capacity à la taille de la propriété, qui définit le nombre de caractères que l’objet peut contenir.If you add characters to the StringBuilder object, its length increases until it equals the size of the StringBuilder.Capacity property, which defines the number of characters that the object can contain. Si le nombre de caractères ajoutés fait que la longueur de StringBuilder l’objet dépasse sa capacité actuelle, la nouvelle mémoire est allouée, la Capacity valeur de la propriété est doublée, de nouveaux caractères StringBuilder sont ajoutés à l’objet et son Lengthla propriété est ajustée.If the number of added characters causes the length of the StringBuilder object to exceed its current capacity, new memory is allocated, the value of the Capacity property is doubled, new characters are added to the StringBuilder object, and its Length property is adjusted. La mémoire supplémentaire pour StringBuilder l’objet est allouée dynamiquement jusqu’à ce qu’elle StringBuilder.MaxCapacity atteigne la valeur définie par la propriété.Additional memory for the StringBuilder object is allocated dynamically until it reaches the value defined by the StringBuilder.MaxCapacity property. Lorsque la capacité maximale est atteinte, aucune mémoire supplémentaire ne peut être allouée pour l’objet, et la StringBuilder tentative d’ajout ou de développement de caractères au-delà de sa capacité maximale lève une ArgumentOutOfRangeException OutOfMemoryException exception ou.When the maximum capacity is reached, no further memory can be allocated for the StringBuilder object, and trying to add characters or expand it beyond its maximum capacity throws either an ArgumentOutOfRangeException or an OutOfMemoryException exception.

L’exemple suivant montre comment un StringBuilder objet alloue de la mémoire et augmente sa capacité de manière dynamique à mesure que la chaîne assignée à l’objet se développe.The following example illustrates how a StringBuilder object allocates new memory and increases its capacity dynamically as the string assigned to the object expands. Le code crée un StringBuilder objet en appelant son constructeur par défaut (sans paramètre).The code creates a StringBuilder object by calling its default (parameterless) constructor. La capacité par défaut de cet objet est de 16 caractères et sa capacité maximale est supérieure à 2 milliards caractères.The default capacity of this object is 16 characters, and its maximum capacity is more than 2 billion characters. Ajout de la chaîne «This is a phrase».Appending the string "This is a sentence." entraîne une nouvelle allocation de mémoire, car la longueur de chaîne (19 caractères) dépasse la capacité par StringBuilder défaut de l’objet.results in a new memory allocation because the string length (19 characters) exceeds the default capacity of the StringBuilder object. 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.The capacity of the object doubles to 32 characters, the new string is added, and the length of the object now equals 19 characters. Le code ajoute ensuite la chaîne «This is an additional phrase».The code then appends the string "This is an additional sentence." à la valeur de l' StringBuilder objet 11 fois.to the value of the StringBuilder object 11 times. Chaque fois que l’opération d’ajout entraîne un StringBuilder dépassement de la capacité de la longueur de l’objet, sa capacité existante Append est doublée et l’opération se déroule correctement.Whenever the append operation causes the length of the StringBuilder object to exceed its capacity, its existing capacity is doubled and the Append operation succeeds.

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
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émoireMemory allocation

La capacité par défaut d' StringBuilder un objet est de 16 caractères et sa capacité maximale par Int32.MaxValuedéfaut est.The default capacity of a StringBuilder object is 16 characters, and its default maximum capacity is Int32.MaxValue. Ces valeurs par défaut sont utilisées si vous appelez StringBuilder() les StringBuilder(String) constructeurs et.These default values are used if you call the StringBuilder() and StringBuilder(String) constructors.

Vous pouvez définir explicitement la capacité initiale d’un StringBuilder objet des manières suivantes:You can explicitly define the initial capacity of a StringBuilder object in the following ways:

  • En appelant l’un des StringBuilder constructeurs qui incluent un capacity paramètre lorsque vous créez l’objet.By calling any of the StringBuilder constructors that includes a capacity parameter when you create the object.

  • En affectant explicitement une nouvelle valeur à la StringBuilder.Capacity propriété pour développer un objet StringBuilder existant.By explicitly assigning a new value to the StringBuilder.Capacity property to expand an existing StringBuilder object. Notez que la propriété lève une exception si la nouvelle capacité est inférieure à la capacité existante ou supérieure à la capacité StringBuilder maximale de l’objet.Note that the property throws an exception if the new capacity is less than the existing capacity or greater than the StringBuilder object's maximum capacity.

  • En appelant la StringBuilder.EnsureCapacity méthode avec la nouvelle capacité.By calling the StringBuilder.EnsureCapacity method with the new capacity. La nouvelle capacité ne doit pas être supérieure à StringBuilder la capacité maximale de l’objet.The new capacity must not be greater than the StringBuilder object's maximum capacity. Toutefois, contrairement à une assignation à Capacity la 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 la méthode n’a aucun effet.However, unlike an assignment to the Capacity property, EnsureCapacity does not throw an exception if the desired new capacity is less than the existing capacity; in this case, the method call has no effect.

Si la longueur de la chaîne assignée StringBuilder à l’objet dans l’appel du constructeur dépasse la capacité par défaut ou la capacité Capacity spécifiée, la propriété est définie à la longueur de la chaîne value spécifiée avec le paramètre.If the length of the string assigned to the StringBuilder object in the constructor call exceeds either the default capacity or the specified capacity, the Capacity property is set to the length of the string specified with the value parameter.

Vous pouvez définir explicitement la capacité maximale d’un StringBuilder objet en appelant le StringBuilder(Int32, Int32) constructeur.You can explicitly define the maximum capacity of a StringBuilder object by calling the StringBuilder(Int32, Int32) constructor. Vous ne pouvez pas modifier la capacité maximale en affectant une nouvelle valeur MaxCapacity à la propriété, car elle est en lecture seule.You can't change the maximum capacity by assigning a new value to the MaxCapacity property, because it is read-only.

Comme le montre la section précédente, chaque fois que la capacité existante est insuffisante, de la mémoire supplémentaire StringBuilder est allouée et la capacité d’un objet MaxCapacity double jusqu’à la valeur définie par la propriété.As the previous section shows, whenever the existing capacity is inadequate, additional memory is allocated and the capacity of a StringBuilder object doubles up to the value defined by the MaxCapacity property.

En général, la capacité par défaut et la capacité maximale sont adaptées à la plupart des applications.In general, the default capacity and maximum capacity are adequate for most apps. Vous pouvez envisager de définir ces valeurs dans les conditions suivantes:You might consider setting these values under the following conditions:

  • Si la taille éventuelle de l' StringBuilder objet est susceptible de croître au-delà de plusieurs mégaoctets.If the eventual size of the StringBuilder object is likely to grow exceedingly large, typically in excess of several megabytes. Dans ce cas, il peut y avoir un avantage en matière de performances Capacity : la définition de la propriété initiale sur une valeur significativement élevée pour éliminer la nécessité d’un trop grand nombre de réallocations de mémoire.In this case, there may be some performance benefit from setting the initial Capacity property to a significantly high value to eliminate the need for too many memory reallocations.

  • Si votre application s’exécute sur un système avec une mémoire limitée.If your app is running on a system with limited memory. Dans ce cas, vous pouvez envisager de définir la MaxCapacity propriété sur une valeur inférieure à Int32.MaxValue si votre application gère des chaînes volumineuses qui peuvent l’entraîner à s’exécuter dans un environnement à mémoire restreinte.In this case, you may want to consider setting the MaxCapacity property to less than Int32.MaxValue if your app is handling large strings that may cause it to execute in a memory-constrained environment.

Instanciation d’un objet StringBuilderInstantiating a StringBuilder object

Vous instanciez StringBuilder un objet en appelant l’un de ses six constructeurs de classe surchargés, qui sont répertoriés dans le tableau suivant.You instantiate a StringBuilder object by calling one of its six overloaded class constructors, which are listed in the following table. Trois des constructeurs instancient un StringBuilder objet dont la valeur est une chaîne vide, mais qui définissent différemment ses Capacity valeurs et MaxCapacity .Three of the constructors instantiate a StringBuilder object whose value is an empty string, but set its Capacity and MaxCapacity values differently. Les trois constructeurs restants définissent un StringBuilder objet qui a une valeur de chaîne et une capacité spécifiques.The remaining three constructors define a StringBuilder object that has a specific string value and capacity. Deux des trois constructeurs utilisent la capacité maximale par défaut de Int32.MaxValue, tandis que la troisième vous permet de définir la capacité maximale.Two of the three constructors use the default maximum capacity of Int32.MaxValue, whereas the third allows you to set the maximum capacity.

ConstructeurConstructor Valeur de chaîneString value CapacitéCapacity Capacité maximaleMaximum capacity
StringBuilder() String.Empty 1616 Int32.MaxValue
StringBuilder(Int32) String.Empty Défini par le capacity paramètreDefined by the capacity parameter Int32.MaxValue
StringBuilder(Int32, Int32) String.Empty Défini par le capacity paramètreDefined by the capacity parameter Défini par le maxCapacity paramètreDefined by the maxCapacity parameter
StringBuilder(String) Défini par le value paramètreDefined by the value parameter 16 ou value.16 or value. Length, selon celui qui est le plus grandLength, whichever is greater Int32.MaxValue
StringBuilder(String, Int32) Défini par le value paramètreDefined by the value parameter Défini par le capacity paramètre ou value.Defined by the capacity parameter or value. Length, la valeur la plus élevée étant applicable.Length, whichever is greater. Int32.MaxValue
StringBuilder(String, Int32, Int32, Int32) défini par value.Defined by value. Substring(startIndex, length)Substring(startIndex, length) Défini par le capacity paramètre ou value.Defined by the capacity parameter or value. Length, la valeur la plus élevée étant applicable.Length, whichever is greater. Défini par le maxCapacity paramètreDefined by the maxCapacity parameter

L’exemple suivant utilise trois de ces surcharges de constructeur pour StringBuilder instancier des objets.The following example uses three of these constructor overloads to instantiate StringBuilder objects.

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

Appeler des méthodes StringBuilderCalling StringBuilder methods

La plupart des méthodes qui modifient la chaîne dans StringBuilder une instance retournent une référence à cette même instance.Most of the methods that modify the string in a StringBuilder instance return a reference to that same instance. Cela vous permet d’appeler StringBuilder des méthodes de deux façons:This enables you to call StringBuilder methods in two ways:

  • Vous pouvez effectuer des appels de méthode individuels et ignorer la valeur de retour, comme le fait l’exemple suivant.You can make individual method calls and ignore the return value, as the following example does.

    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.
    
    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.You can make a series of method calls in a single statement. Cela peut être pratique si vous souhaitez écrire une seule instruction qui chaîne des opérations successives.This can be convenient if you want to write a single statement that chains successive operations. L’exemple suivant consolide trois appels de méthode de l’exemple précédent en une seule ligne de code.The following example consolidates three method calls from the previous example into a single line of 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.
    
    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 StringBuilderPerforming StringBuilder operations

Vous pouvez utiliser les méthodes de la StringBuilder classe pour itérer, ajouter, supprimer ou modifier des caractères dans un StringBuilder objet.You can use the methods of the StringBuilder class to iterate, add, delete, or modify characters in a StringBuilder object.

Itération des caractères StringBuilderIterating StringBuilder characters

Vous pouvez accéder aux caractères d’un StringBuilder objet à l’aide StringBuilder.Chars[Int32] de la propriété.You can access the characters in a StringBuilder object by using the StringBuilder.Chars[Int32] property. Dans C#, Chars[Int32] est un indexeur; dans Visual Basic, il s’agit de la propriété par StringBuilder défaut de la classe.In C#, Chars[Int32] is an indexer; in Visual Basic, it is the default property of the StringBuilder class. Cela vous permet de définir ou de récupérer des caractères individuels à l’aide de leur index uniquement, Chars[Int32] sans référence explicite à la propriété.This enables you to set or retrieve individual characters by using their index only, without explicitly referencing the Chars[Int32] property. Les caractères d' StringBuilder un objet commencent à l’index 0 (zéro) et continuent Length à indexer-1.Characters in a StringBuilder object begin at index 0 (zero) and continue to index Length - 1.

L’exemple suivant illustre la Chars[Int32] propriété.The following example illustrates the Chars[Int32] property. Il ajoute dix nombres aléatoires à un StringBuilder objet, puis itère chaque caractère.It appends ten random numbers to a StringBuilder object, and then iterates each character. 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).If the character's Unicode category is UnicodeCategory.DecimalDigitNumber, it decreases the number by 1 (or changes the number to 9 if its value is 0). L’exemple affiche le contenu de l' StringBuilder objet avant et après la modification des valeurs des caractères individuels.The example displays the contents of the StringBuilder object both before and after the values of individual characters were changed.

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
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[Int32] peut être très lente dans les conditions suivantes :Using character-based indexing with the Chars[Int32] property can be extremely slow under the following conditions:

  • L’instance de StringBuilder est grande (par exemple, elle est constituée de plusieurs dizaines de milliers de caractères).The StringBuilder instance is large (for example, it consists of several tens of thousands of characters).
  • StringBuilder contient des grands blocs.The StringBuilder is "chunky." Autrement dit, des appels répétés à des méthodes comme StringBuilder.Append ont développé automatiquement la propriété StringBuilder.Capacity de l’objet et lui ont alloué de nouveaux blocs de mémoire.That is, repeated calls to methods such as StringBuilder.Append have automatically expanded the object's StringBuilder.Capacity property and allocated new chunks of memory to it.

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.Performance is severely impacted because each character access walks the entire linked list of chunks to find the correct buffer to index into.

Notes

Même pour un grand objet StringBuilder avec des gros blocs, l’utilisation de la propriété Chars[Int32] pour l’accès basé sur un index à un seul caractère 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 0(n) .Even for a large "chunky" StringBuilder object, using the Chars[Int32] property for index-based access to one or a small number of characters has a negligible performance impact; typically, it is an 0(n) operation. 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) .The significant performance impact occurs when iterating the characters in the StringBuilder object, which is an O(n^2) operation.

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 :If you encounter performance issues when using character-based indexing with StringBuilder objects, you can use any of the following workarounds:

  • Convertissez l’instance de StringBuilder en String en appelant la méthode ToString, puis accédez aux caractères de la chaîne.Convert the StringBuilder instance to a String by calling the ToString method, then access the characters in the string.

  • Copiez le contenu de l’objet StringBuilder existant dans un objet StringBuilder prédimensionné.Copy the contents of the existing StringBuilder object to a new pre-sized StringBuilder object. Les performances s’améliorent, car le nouvel objet StringBuilder ne contient pas de gros blocs.Performance improves because the new StringBuilder object is not chunky. Par exemple :For example:

    // 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).Set the initial capacity of the StringBuilder object to a value that is approximately equal to its maximum expected size by calling the StringBuilder(Int32) constructor. Notez que ceci alloue l’intégralité du bloc de mémoire, même si StringBuilder atteint rarement sa capacité maximale.Note that this allocates the entire block of memory even if the StringBuilder rarely reaches its maximum capacity.

Ajout de texte à un objet StringBuilderAdding text to a StringBuilder object

La StringBuilder classe comprend les méthodes suivantes pour développer le contenu d’un StringBuilder objet:The StringBuilder class includes the following methods for expanding the contents of a StringBuilder object:

  • 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 StringBuilder type de données primitif à un objet.The Append method appends a string, a substring, a character array, a portion of a character array, a single character repeated multiple times, or the string representation of a primitive data type to a StringBuilder object.

  • La AppendLine méthode ajoute un terminateur de ligne ou une chaîne avec une marque de fin de ligne StringBuilder à un objet.The AppendLine method appends a line terminator or a string along with a line terminator to a StringBuilder object.

  • La AppendFormat méthode ajoute une chaîne de format composite à StringBuilder un objet.The AppendFormat method appends a composite format string to a StringBuilder object. Les représentations sous forme de chaîne des 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.The string representations of objects included in the result string can reflect the formatting conventions of the current system culture or a specified culture.

  • 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 StringBuilder position spécifiée dans l’objet.The Insert method inserts a string, a substring, multiple repetitions of a string, a character array, a portion of a character array, or the string representation of a primitive data type at a specified position in the StringBuilder object. La position est définie par un index de base zéro.The position is defined by a zero-based index.

L’exemple suivant utilise les Appendméthodes AppendLine AppendFormat,, et Insert pour développer le texte d’un StringBuilder objet.The following example uses the Append, AppendLine, AppendFormat, and Insert methods to expand the text of a StringBuilder object.

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            <
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 StringBuilderDeleting text from a StringBuilder object

La StringBuilder classe comprend des méthodes qui peuvent réduire la taille de l' StringBuilder instance actuelle.The StringBuilder class includes methods that can reduce the size of the current StringBuilder instance. La Clear méthode supprime tous les caractères et affecte Length à la propriété la valeur zéro.The Clear method removes all characters and sets the Length property to zero. La Remove méthode supprime un nombre spécifié de caractères en commençant à une position d’index particulière.The Remove method deletes a specified number of characters starting at a particular index position. En outre, vous pouvez supprimer des caractères à la fin d' StringBuilder un objet en affectant à sa Length propriété une valeur inférieure à la longueur de l’instance actuelle.In addition, you can remove characters from the end of a StringBuilder object by setting its Length property to a value that is less than the length of the current instance.

L’exemple suivant supprime une partie du texte d’un StringBuilder objet, affiche sa capacité résultante, la capacité maximale et les valeurs de propriété de longueur, Clear puis appelle la méthode pour supprimer tous les StringBuilder caractères de l’objet.The following example removes some of the text from a StringBuilder object, displays its resulting capacity, maximum capacity, and length property values, and then calls the Clear method to remove all the characters from the StringBuilder object.

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
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 StringBuilderModifying the text in a StringBuilder object

La StringBuilder.Replace méthode remplace toutes les occurrences d’un caractère ou d’une chaîne dans StringBuilder l’objet entier ou dans une plage de caractères particulière.The StringBuilder.Replace method replaces all occurrences of a character or a string in the entire StringBuilder object or in a particular character range. L’exemple suivant utilise la Replace méthode pour remplacer tous les points d’exclamation (!) par des points d’interrogation (? StringBuilder ) dans l’objet.The following example uses the Replace method to replace all exclamation points (!) with question marks (?) in the StringBuilder object.

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?
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 dans le texte d’un objet StringBuilderSearching the text in a StringBuilder object

La StringBuilder classe n’inclut pas de méthodes similaires String.Containsaux méthodes String.IndexOf, et String.StartsWith fournies par la String classe, ce qui vous permet de rechercher un caractère particulier ou une sous-chaîne dans l’objet.The StringBuilder class does not include methods similar to the String.Contains, String.IndexOf, and String.StartsWith methods provided by the String class, which allow you to search the object for a particular character or a substring. Pour déterminer la présence ou la position de caractère de départ d’une sous-chaîne String , vous devez rechercher une valeur à l’aide d’une méthode de recherche de chaîne ou d’une méthode d’expression régulière.Determining the presence or starting character position of a substring requires that you search a String value by using either a string search method or a regular expression method. Il existe quatre façons d’implémenter ces recherches, comme le montre le tableau suivant.There are four ways to implement such searches, as the following table shows.

TechniqueTechnique AvantagesPros InconvénientsCons
Recherchez les valeurs de chaîne avant de les StringBuilder ajouter à l’objet.Search string values before adding them to the StringBuilder object. Utile pour déterminer si une sous-chaîne existe.Useful for determining whether a substring exists. Ne peut pas être utilisé lorsque la position d’index d’une sous-chaîne est importante.Cannot be used when the index position of a substring is important.
Appelez ToString et recherchez l’objet String retourné.Call ToString and search the returned String object. Facile à utiliser si vous assignez tout le texte StringBuilder à un objet, puis commencez à le modifier.Easy to use if you assign all the text to a StringBuilder object, and then begin to modify it. Appelez ToString à plusieurs reprises si vous devez apporter des modifications avant que tout le texte soit ajouté StringBuilder à l’objet.Cumbersome to repeatedly call ToString if you must make modifications before all text is added to the StringBuilder object.

Vous devez vous souvenir de travailler à partir de la StringBuilder fin du texte de l’objet si vous apportez des modifications.You must remember to work from the end of the StringBuilder object's text if you're making changes.
Utilisez la Chars[Int32] propriété pour effectuer une recherche séquentielle dans une plage de caractères.Use the Chars[Int32] property to sequentially search a range of characters. Utile si vous vous intéressez à des caractères individuels ou à une petite sous-chaîne.Useful if you're concerned with individual characters or a small substring. Fastidieux si le nombre de caractères à rechercher est important ou si la logique de recherche est complexe.Cumbersome if the number of characters to search is large or if the search logic is complex.

Entraîne des performances très médiocres pour les objets qui ont été développés très largement par le biais d’appels de méthode répétés.Results in very poor performance for objects that have grown very large through repeated method calls.
Convertit l' StringBuilder objet String en objet et effectue des modifications sur String l’objet.Convert the StringBuilder object to a String object, and perform modifications on the String object. Utile si le nombre de modifications est faible.Useful if the number of modifications is small. Nie l’avantage en matière de performances StringBuilder de la classe si le nombre de modifications est important.Negates the performance benefit of the StringBuilder class if the number of modifications is large.

Examinons ces techniques plus en détail.Let's examine these techniques in greater detail.

  • 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 StringBuilder avant de les stocker dans l’objet.If the goal of the search is to determine whether a particular substring exists (that is, if you aren't interested in the position of the substring), you can search strings before storing them in the StringBuilder object. L’exemple suivant fournit une implémentation possible.The following example provides one possible implementation. Il définit une StringBuilderFinder classe dont le constructeur reçoit une référence à un StringBuilder objet et la sous-chaîne à rechercher dans la chaîne.It defines a StringBuilderFinder class whose constructor is passed a reference to a StringBuilder object and the substring to find in the string. Dans ce cas, l’exemple tente de déterminer si les températures enregistrées sont en degrés Fahrenheit ou Celsius, et ajoute le texte d’introduction approprié au début StringBuilder de l’objet.In this case, the example tries to determine whether recorded temperatures are in Fahrenheit or Celsius, and adds the appropriate introductory text to the beginning of the StringBuilder object. Un générateur de nombres aléatoires est utilisé pour sélectionner un tableau qui contient des données de degrés Celsius ou Fahrenheit.A random number generator is used to select an array that contains data in either degrees Celsius or degrees 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
    
    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' StringBuilder objet en String objet.Call the StringBuilder.ToString method to convert the StringBuilder object to a String object. Vous pouvez effectuer une recherche dans la chaîne à l' String.LastIndexOf aide String.StartsWithde méthodes telles que ou, ou vous pouvez Regex utiliser des expressions régulières et la classe pour rechercher des modèles.You can search the string by using methods such as String.LastIndexOf or String.StartsWith, or you can use regular expressions and the Regex class to search for patterns. Étant donné que String les objets etutilisentl’encodageUTF-16pourstockerdescaractères,lespositionsd’indexdescaractères,lessous-chaînesetlescorrespondancesd’expressionsrégulièressontlesmêmesdanslesdeuxobjets.StringBuilderBecause both StringBuilder and String objects use UTF-16 encoding to store characters, the index positions of characters, substrings, and regular expression matches are the same in both objects. Cela vous permet d’utiliser StringBuilder des méthodes pour apporter des modifications à la même position que celle où se trouve ce String texte dans l’objet.This enables you to use StringBuilder methods to make changes at the same position at which that text is found in the String object.

    Notes

    Si vous adoptez cette approche, vous devez travailler à partir de la StringBuilder fin de l’objet jusqu’au début afin de ne pas avoir à convertir StringBuilder à plusieurs reprises l’objet en chaîne.If you adopt this approach, you should work from the end of the StringBuilder object to its beginning so that you don't have to repeatedly convert the StringBuilder object to a string.

    L'exemple suivant illustre cette approche.The following example illustrates this approach. Il stocke quatre occurrences de chaque lettre de l’alphabet anglais dans StringBuilder un objet.It stores four occurrences of each letter of the English alphabet in a StringBuilder object. Il convertit ensuite le texte en String un objet et utilise une expression régulière pour identifier la position de départ de chaque séquence de quatre caractères.It then converts the text to a String object and uses a regular expression to identify the starting position of each four-character sequence. 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.Finally, it adds an underscore before each four-character sequence except for the first sequence, and converts the first character of the sequence to uppercase.

    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
    
    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[Int32] propriété pour effectuer une recherche séquentielle dans une plage de caractères StringBuilder d’un objet.Use the StringBuilder.Chars[Int32] property to sequentially search a range of characters in a StringBuilder object. Cette approche peut ne pas être pratique si le nombre de caractères à rechercher est important ou si la logique de recherche est particulièrement complexe.This approach may not be practical if the number of characters to be searched is large or the search logic is particularly complex. Pour plus d’informations sur les performances de l’accès par index basé sur des caractères par caractère pour les StringBuilder objets en bloc volumineux, consultez la StringBuilder.Chars[Int32] documentation de la propriété.For the performance implications of character-by-character index-based access for very large, chunked StringBuilder objects, see the documentation for the StringBuilder.Chars[Int32] property.

    L’exemple suivant est identique dans les fonctionnalités de l’exemple précédent, mais diffère dans l’implémentation.The following example is identical in functionality to the previous example but differs in implementation. Elle utilise la Chars[Int32] 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.It uses the Chars[Int32] property to detect when a character value has changed, inserts an underscore at that position, and converts the first character in the new sequence to uppercase.

    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
    
    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 StringBuilder l’objet, appelez StringBuilder.ToString la méthode pour String convertir StringBuilder l’objet en objet et effectuez les modifications sur l' String objet.Store all the unmodified text in the StringBuilder object, call the StringBuilder.ToString method to convert the StringBuilder object to a String object, and perform the modifications on the String object. Vous pouvez utiliser cette approche si vous n’avez que quelques modifications; dans le cas contraire, le coût de l’utilisation de chaînes immuables peut altérer les avantages StringBuilder en matière de performances de l’utilisation d’un objet.You can use this approach if you have only a few modifications; otherwise, the cost of working with immutable strings may negate the performance benefits of using a StringBuilder object.

    L’exemple suivant est identique dans les fonctionnalités des deux exemples précédents, mais diffère dans l’implémentation.The following example is identical in functionality to the previous two examples but differs in implementation. Il crée un StringBuilder objet, le convertit String en objet, puis utilise une expression régulière pour effectuer toutes les modifications restantes de la chaîne.It creates a StringBuilder object, converts it to a String object, and then uses a regular expression to perform all remaining modifications on the string. La Regex.Replace(String, String, MatchEvaluator) méthode utilise une expression lambda pour effectuer le remplacement sur chaque correspondance.The Regex.Replace(String, String, MatchEvaluator) method uses a lambda expression to perform the replacement on each match.

    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
    
    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îneConverting the StringBuilder object to a string

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.You must convert the StringBuilder object to a String object before you can pass the string represented by the StringBuilder object to a method that has a String parameter or display it in the user interface. Vous effectuez cette conversion en appelant la StringBuilder.ToString méthode.You perform this conversion by calling the StringBuilder.ToString method. Pour obtenir une illustration, consultez l’exemple précédent, qui appelle ToString la méthode pour convertir StringBuilder un objet en une chaîne afin qu’il puisse être passé à une méthode d’expression régulière.For an illustration, see the previous example, which calls the ToString method to convert a StringBuilder object to a string so that it can be passed to a regular expression method.

Notes pour les appelants

Dans .net Core et dans le .NET Framework 4,0 et versions ultérieures, quand StringBuilder vous instanciez l’objet en appelant le StringBuilder(Int32, Int32) constructeur, la longueur et la capacité de StringBuilder l’instance peuvent croître au-delà de MaxCapacity la valeur de son propriété.In .NET Core and in the .NET Framework 4.0 and later versions, when you instantiate the StringBuilder object by calling the StringBuilder(Int32, Int32) constructor, both the length and the capacity of the StringBuilder instance can grow beyond the value of its MaxCapacity property. Cela peut se produire en particulier lorsque vous Append(String) appelez AppendFormat(String, Object) les méthodes et pour ajouter des chaînes de petite taille.This can occur particularly when you call the Append(String) and AppendFormat(String, Object) methods to append small strings.

Constructeurs

StringBuilder() StringBuilder() StringBuilder() StringBuilder()

Initialise une nouvelle instance de la classe StringBuilder.Initializes a new instance of the StringBuilder class.

StringBuilder(Int32) StringBuilder(Int32) StringBuilder(Int32) StringBuilder(Int32)

Initialise une nouvelle instance de la classe StringBuilder en utilisant la capacité spécifiée.Initializes a new instance of the StringBuilder class using the specified capacity.

StringBuilder(Int32, Int32) StringBuilder(Int32, Int32) StringBuilder(Int32, Int32) 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é.Initializes a new instance of the StringBuilder class that starts with a specified capacity and can grow to a specified maximum.

StringBuilder(String) StringBuilder(String) StringBuilder(String) StringBuilder(String)

Initialise une nouvelle instance de la classe StringBuilder à l'aide de la chaîne spécifiée.Initializes a new instance of the StringBuilder class using the specified string.

StringBuilder(String, Int32) StringBuilder(String, Int32) StringBuilder(String, Int32) StringBuilder(String, Int32)

Initialise une nouvelle instance de la classe StringBuilder en utilisant la chaîne et la capacité spécifiées.Initializes a new instance of the StringBuilder class using the specified string and capacity.

StringBuilder(String, Int32, Int32, Int32) StringBuilder(String, Int32, Int32, Int32) StringBuilder(String, Int32, Int32, Int32) 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.Initializes a new instance of the StringBuilder class from the specified substring and capacity.

Propriétés

Capacity Capacity Capacity Capacity

Obtient ou définit le nombre maximal de caractères que peut contenir la mémoire allouée par l'instance actuelle.Gets or sets the maximum number of characters that can be contained in the memory allocated by the current instance.

Chars[Int32] Chars[Int32] Chars[Int32] Chars[Int32]

Obtient ou définit le caractère situé à la position de caractère spécifiée dans cette instance.Gets or sets the character at the specified character position in this instance.

Length Length Length Length

Obtient ou définit la longueur de l'objet StringBuilder actuel.Gets or sets the length of the current StringBuilder object.

MaxCapacity MaxCapacity MaxCapacity MaxCapacity

Obtient la capacité maximale de cette instance.Gets the maximum capacity of this instance.

Méthodes

Append(Boolean) Append(Boolean) Append(Boolean) Append(Boolean)

Ajoute à cette instance la représentation sous forme de chaîne d'une valeur booléenne spécifiée.Appends the string representation of a specified Boolean value to this instance.

Append(Byte) Append(Byte) Append(Byte) Append(Byte)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 8 bits non signé spécifié.Appends the string representation of a specified 8-bit unsigned integer to this instance.

Append(Char) Append(Char) Append(Char) Append(Char)

Ajoute à cette instance la représentation sous forme de chaîne d’un objet Char spécifié.Appends the string representation of a specified Char object to this instance.

Append(Char*, Int32) Append(Char*, Int32) Append(Char*, Int32) Append(Char*, Int32)

Ajoute à cette instance un tableau de caractères Unicode commençant à une adresse spécifiée.Appends an array of Unicode characters starting at a specified address to this instance.

Append(Char, Int32) Append(Char, Int32) Append(Char, Int32) 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.Appends a specified number of copies of the string representation of a Unicode character to this instance.

Append(Char[]) Append(Char[]) Append(Char[]) Append(Char[])

Ajoute à cette instance la représentation sous forme de chaîne des caractères Unicode d'un tableau spécifié.Appends the string representation of the Unicode characters in a specified array to this instance.

Append(Char[], Int32, Int32) Append(Char[], Int32, Int32) Append(Char[], Int32, Int32) 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.Appends the string representation of a specified subarray of Unicode characters to this instance.

Append(Decimal) Append(Decimal) Append(Decimal) Append(Decimal)

Ajoute à cette instance la représentation sous forme de chaîne d'un nombre décimal spécifié.Appends the string representation of a specified decimal number to this instance.

Append(Double) Append(Double) Append(Double) Append(Double)

Ajoute à cette instance la représentation sous forme de chaîne d'un nombre à virgule flottante double précision spécifié.Appends the string representation of a specified double-precision floating-point number to this instance.

Append(Int16) Append(Int16) Append(Int16) Append(Int16)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 16 bits signé spécifié.Appends the string representation of a specified 16-bit signed integer to this instance.

Append(Int32) Append(Int32) Append(Int32) Append(Int32)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 32 bits signé spécifié.Appends the string representation of a specified 32-bit signed integer to this instance.

Append(Int64) Append(Int64) Append(Int64) Append(Int64)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 64 bits signé spécifié.Appends the string representation of a specified 64-bit signed integer to this instance.

Append(Object) Append(Object) Append(Object) Append(Object)

Ajoute à cette instance la représentation sous forme de chaîne d'un objet spécifié.Appends the string representation of a specified object to this instance.

Append(ReadOnlyMemory<Char>) Append(ReadOnlyMemory<Char>) Append(ReadOnlyMemory<Char>) 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.Appends the string representation of a specified read-only character memory region to this instance.

Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>) 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.Appends the string representation of a specified read-only character span to this instance.

Append(SByte) Append(SByte) Append(SByte) Append(SByte)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 8 bits signé spécifié.Appends the string representation of a specified 8-bit signed integer to this instance.

Append(Single) Append(Single) Append(Single) Append(Single)

Ajoute à cette instance la représentation sous forme de chaîne d'un nombre à virgule flottante simple précision spécifié.Appends the string representation of a specified single-precision floating-point number to this instance.

Append(String) Append(String) Append(String) Append(String)

Ajoute à cette instance une copie de la chaîne spécifiée.Appends a copy of the specified string to this instance.

Append(String, Int32, Int32) Append(String, Int32, Int32) Append(String, Int32, Int32) Append(String, Int32, Int32)

Ajoute à cette instance une copie d'une sous-chaîne spécifiée.Appends a copy of a specified substring to this instance.

Append(StringBuilder) Append(StringBuilder) Append(StringBuilder) Append(StringBuilder)

Ajoute à cette instance la représentation sous forme de chaîne d’un générateur de chaînes spécifié.Appends the string representation of a specified string builder to this instance.

Append(StringBuilder, Int32, Int32) Append(StringBuilder, Int32, Int32) Append(StringBuilder, Int32, Int32) Append(StringBuilder, Int32, Int32)

Ajoute à cette instance une copie d’une sous-chaîne du générateur de chaînes spécifié.Appends a copy of a substring within a specified string builder to this instance.

Append(UInt16) Append(UInt16) Append(UInt16) Append(UInt16)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 16 bits non signé spécifié.Appends the string representation of a specified 16-bit unsigned integer to this instance.

Append(UInt32) Append(UInt32) Append(UInt32) Append(UInt32)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 32 bits non signé spécifié.Appends the string representation of a specified 32-bit unsigned integer to this instance.

Append(UInt64) Append(UInt64) Append(UInt64) Append(UInt64)

Ajoute à cette instance la représentation sous forme de chaîne d'un entier 64 bits non signé spécifié.Appends the string representation of a specified 64-bit unsigned integer to this instance.

AppendFormat(IFormatProvider, String, Object) AppendFormat(IFormatProvider, String, Object) AppendFormat(IFormatProvider, String, Object) 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.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. 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é.Each format item is replaced by the string representation of a single argument using a specified format provider.

AppendFormat(IFormatProvider, String, Object, Object) AppendFormat(IFormatProvider, String, Object, Object) AppendFormat(IFormatProvider, String, Object, Object) 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.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. 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é.Each format item is replaced by the string representation of either of two arguments using a specified format provider.

AppendFormat(IFormatProvider, String, Object, Object, Object) AppendFormat(IFormatProvider, String, Object, Object, Object) AppendFormat(IFormatProvider, String, Object, Object, Object) 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.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. 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é.Each format item is replaced by the string representation of either of three arguments using a specified format provider.

AppendFormat(IFormatProvider, String, Object[]) AppendFormat(IFormatProvider, String, Object[]) AppendFormat(IFormatProvider, String, Object[]) 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.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. 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é.Each format item is replaced by the string representation of a corresponding argument in a parameter array using a specified format provider.

AppendFormat(String, Object) AppendFormat(String, Object) AppendFormat(String, Object) 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.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Chaque élément de format est remplacé par la représentation sous forme de chaîne d'un argument unique.Each format item is replaced by the string representation of a single argument.

AppendFormat(String, Object, Object) AppendFormat(String, Object, Object) AppendFormat(String, Object, Object) 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.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Chaque élément de format est remplacé par la représentation sous forme de chaîne de l'un des deux arguments possibles.Each format item is replaced by the string representation of either of two arguments.

AppendFormat(String, Object, Object, Object) AppendFormat(String, Object, Object, Object) AppendFormat(String, Object, Object, Object) 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.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Chaque élément de format est remplacé par la représentation sous forme de chaîne de l'un des trois arguments possibles.Each format item is replaced by the string representation of either of three arguments.

AppendFormat(String, Object[]) AppendFormat(String, Object[]) AppendFormat(String, Object[]) 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.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. 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.Each format item is replaced by the string representation of a corresponding argument in a parameter array.

AppendJoin(Char, Object[]) AppendJoin(Char, Object[]) AppendJoin(Char, Object[]) AppendJoin(Char, Object[])
AppendJoin(Char, String[]) AppendJoin(Char, String[]) AppendJoin(Char, String[]) AppendJoin(Char, String[])
AppendJoin(String, Object[]) AppendJoin(String, Object[]) AppendJoin(String, Object[]) AppendJoin(String, Object[])
AppendJoin(String, String[]) AppendJoin(String, String[]) AppendJoin(String, String[]) AppendJoin(String, String[])
AppendJoin<T>(Char, IEnumerable<T>) AppendJoin<T>(Char, IEnumerable<T>) AppendJoin<T>(Char, IEnumerable<T>) AppendJoin<T>(Char, IEnumerable<T>)
AppendJoin<T>(String, IEnumerable<T>) AppendJoin<T>(String, IEnumerable<T>) AppendJoin<T>(String, IEnumerable<T>) AppendJoin<T>(String, IEnumerable<T>)
AppendLine() AppendLine() AppendLine() AppendLine()

Ajoute la marque de fin de ligne par défaut à la fin de l'objet StringBuilder actuel.Appends the default line terminator to the end of the current StringBuilder object.

AppendLine(String) AppendLine(String) AppendLine(String) 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.Appends a copy of the specified string followed by the default line terminator to the end of the current StringBuilder object.

Clear() Clear() Clear() Clear()

Supprime tous les caractères de l'instance StringBuilder actuelle.Removes all characters from the current StringBuilder instance.

CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) 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.Copies the characters from a specified segment of this instance to a specified segment of a destination Char array.

CopyTo(Int32, Span<Char>, Int32) CopyTo(Int32, Span<Char>, Int32) CopyTo(Int32, Span<Char>, Int32) CopyTo(Int32, Span<Char>, Int32)
EnsureCapacity(Int32) EnsureCapacity(Int32) EnsureCapacity(Int32) EnsureCapacity(Int32)

Garantit que la capacité de cette instance de StringBuilder est au moins égale à la valeur spécifiée.Ensures that the capacity of this instance of StringBuilder is at least the specified value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Equals(ReadOnlySpan<Char>) Equals(ReadOnlySpan<Char>) Equals(ReadOnlySpan<Char>) 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.Returns a value indicating whether the characters in this instance are equal to the characters in a specified read-only character span.

Equals(StringBuilder) Equals(StringBuilder) Equals(StringBuilder) Equals(StringBuilder)

Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.Returns a value indicating whether this instance is equal to a specified object.

GetChunks() GetChunks() GetChunks() 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.Returns an object that can be used to iterate through the chunks of characters represented in a ReadOnlyMemory<Char> created from this StringBuilder instance.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
Insert(Int32, Boolean) Insert(Int32, Boolean) Insert(Int32, Boolean) 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.Inserts the string representation of a Boolean value into this instance at the specified character position.

Insert(Int32, Byte) Insert(Int32, Byte) Insert(Int32, Byte) 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é.Inserts the string representation of a specified 8-bit unsigned integer into this instance at the specified character position.

Insert(Int32, Char) Insert(Int32, Char) Insert(Int32, Char) 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é.Inserts the string representation of a specified Unicode character into this instance at the specified character position.

Insert(Int32, Char[]) Insert(Int32, Char[]) Insert(Int32, Char[]) 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é.Inserts the string representation of a specified array of Unicode characters into this instance at the specified character position.

Insert(Int32, Char[], Int32, Int32) Insert(Int32, Char[], Int32, Int32) Insert(Int32, Char[], Int32, Int32) 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é.Inserts the string representation of a specified subarray of Unicode characters into this instance at the specified character position.

Insert(Int32, Decimal) Insert(Int32, Decimal) Insert(Int32, Decimal) 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.Inserts the string representation of a decimal number into this instance at the specified character position.

Insert(Int32, Double) Insert(Int32, Double) Insert(Int32, Double) 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.Inserts the string representation of a double-precision floating-point number into this instance at the specified character position.

Insert(Int32, Int16) Insert(Int32, Int16) Insert(Int32, Int16) 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é.Inserts the string representation of a specified 16-bit signed integer into this instance at the specified character position.

Insert(Int32, Int32) Insert(Int32, Int32) Insert(Int32, Int32) 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é.Inserts the string representation of a specified 32-bit signed integer into this instance at the specified character position.

Insert(Int32, Int64) Insert(Int32, Int64) Insert(Int32, Int64) 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.Inserts the string representation of a 64-bit signed integer into this instance at the specified character position.

Insert(Int32, Object) Insert(Int32, Object) Insert(Int32, Object) 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.Inserts the string representation of an object into this instance at the specified character position.

Insert(Int32, ReadOnlySpan<Char>) Insert(Int32, ReadOnlySpan<Char>) Insert(Int32, ReadOnlySpan<Char>) Insert(Int32, ReadOnlySpan<Char>)
Insert(Int32, SByte) Insert(Int32, SByte) Insert(Int32, SByte) 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é.Inserts the string representation of a specified 8-bit signed integer into this instance at the specified character position.

Insert(Int32, Single) Insert(Int32, Single) Insert(Int32, Single) 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.Inserts the string representation of a single-precision floating point number into this instance at the specified character position.

Insert(Int32, String) Insert(Int32, String) Insert(Int32, String) Insert(Int32, String)

Insère une chaîne dans cette instance, à la position de caractère spécifiée.Inserts a string into this instance at the specified character position.

Insert(Int32, String, Int32) Insert(Int32, String, Int32) Insert(Int32, String, Int32) 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.Inserts one or more copies of a specified string into this instance at the specified character position.

Insert(Int32, UInt16) Insert(Int32, UInt16) Insert(Int32, UInt16) 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.Inserts the string representation of a 16-bit unsigned integer into this instance at the specified character position.

Insert(Int32, UInt32) Insert(Int32, UInt32) Insert(Int32, UInt32) 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.Inserts the string representation of a 32-bit unsigned integer into this instance at the specified character position.

Insert(Int32, UInt64) Insert(Int32, UInt64) Insert(Int32, UInt64) 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.Inserts the string representation of a 64-bit unsigned integer into this instance at the specified character position.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32)

Supprime de cette instance la plage de caractères spécifiée.Removes the specified range of characters from this instance.

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) Replace(Char, Char)

Remplace toutes les occurrences d'un caractère spécifié dans cette instance par un autre caractère spécifié.Replaces all occurrences of a specified character in this instance with another specified character.

Replace(Char, Char, Int32, Int32) Replace(Char, Char, Int32, Int32) Replace(Char, Char, Int32, Int32) 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é.Replaces, within a substring of this instance, all occurrences of a specified character with another specified character.

Replace(String, String) Replace(String, String) Replace(String, String) 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.Replaces all occurrences of a specified string in this instance with another specified string.

Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) 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.Replaces, within a substring of this instance, all occurrences of a specified string with another specified string.

ToString() ToString() ToString() ToString()

Convertit la valeur de cette instance en String.Converts the value of this instance to a String.

ToString(Int32, Int32) ToString(Int32, Int32) ToString(Int32, Int32) ToString(Int32, Int32)

Convertit la valeur d'une sous-chaîne de cette instance en String.Converts the value of a substring of this instance to a String.

Implémentations d’interfaces explicites

ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Remplit un objet SerializationInfo avec les données nécessaires pour désérialiser l'objet StringBuilder actuel.Populates a SerializationInfo object with the data necessary to deserialize the current StringBuilder object.

S’applique à

Voir aussi