StringBuilder Classe

Definizione

Rappresenta una stringa modificabile di caratteri.Represents a mutable string of characters. Questa classe non può essere ereditata.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
Ereditarietà
StringBuilder
Attributi
Implementazioni

Esempi

Nell'esempio seguente viene illustrato come chiamare molti dei metodi definiti dalla classe StringBuilder.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

Commenti

Questa classe rappresenta un oggetto di tipo stringa il cui valore è una sequenza di caratteri modificabile.This class represents a string-like object whose value is a mutable sequence of characters.

Contenuto della sezione:In this section:

Tipi stringa e StringBuilderThe String and StringBuilder types

Sebbene StringBuilder e String entrambi rappresentino sequenze di caratteri, vengono implementate in modo diverso.Although StringBuilder and String both represent sequences of characters, they are implemented differently. String è un tipo non modificabile.String is an immutable type. Ovvero, ogni operazione che sembra modificare un oggetto String crea effettivamente una nuova stringa.That is, each operation that appears to modify a String object actually creates a new string.

La chiamata al metodo String.Concat nell'esempio seguente C# , ad esempio, appare per modificare il valore di una variabile di stringa denominata 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. Il metodo Concat restituisce infatti un oggetto value con un valore e un indirizzo diversi dall'oggetto value passato al metodo.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. Si noti che l'esempio deve essere compilato usando l'opzione del compilatore /unsafe.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

Per le routine che eseguono una manipolazione estesa delle stringhe, ad esempio le app che modificano una stringa numerose volte in un ciclo, la modifica ripetuta di una stringa può comportare un significativo calo delle prestazioni.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'alternativa consiste nell'utilizzare StringBuilder, ovvero una classe stringa modificabile.The alternative is to use StringBuilder, which is a mutable string class. La mutabilità significa che una volta creata un'istanza della classe, è possibile modificarla accodando, rimuovendo, sostituendo o inserendo caratteri.Mutability means that once an instance of the class has been created, it can be modified by appending, removing, replacing, or inserting characters. Un oggetto StringBuilder gestisce un buffer per supportare le espansioni alla stringa.A StringBuilder object maintains a buffer to accommodate expansions to the string. I nuovi dati vengono aggiunti al buffer se è disponibile spazio; in caso contrario, viene allocato un nuovo buffer di dimensioni maggiori, i dati del buffer originale vengono copiati nel nuovo buffer e i nuovi dati vengono quindi aggiunti al nuovo buffer.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.

Importante

Sebbene la classe StringBuilder offra in genere prestazioni migliori rispetto alla classe String, non sostituire automaticamente String con StringBuilder quando si desidera modificare le stringhe.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. Le prestazioni dipendono dalle dimensioni della stringa, dalla quantità di memoria da allocare per la nuova stringa, dal sistema in cui è in esecuzione l'app e dal tipo di operazione.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. È necessario essere pronti a testare l'app per determinare se StringBuilder offre effettivamente un miglioramento significativo delle prestazioni.You should be prepared to test your app to determine whether StringBuilder actually offers a significant performance improvement.

In queste condizioni, provare a usare la classe String:Consider using the String class under these conditions:

  • Quando il numero di modifiche apportate dall'app a una stringa è ridotto.When the number of changes that your app will make to a string is small. In questi casi, StringBuilder potrebbe offrire un miglioramento delle prestazioni trascurabile o senza String.In these cases, StringBuilder might offer negligible or no performance improvement over String.

  • Quando si esegue un numero fisso di operazioni di concatenazione, in particolare con valori letterali stringa.When you are performing a fixed number of concatenation operations, particularly with string literals. In questo caso, il compilatore potrebbe combinare le operazioni di concatenazione in un'unica operazione.In this case, the compiler might combine the concatenation operations into a single operation.

  • Quando è necessario eseguire operazioni di ricerca estese durante la compilazione della stringa.When you have to perform extensive search operations while you are building your string. La classe StringBuilder non dispone di metodi di ricerca come IndexOf o StartsWith.The StringBuilder class lacks search methods such as IndexOf or StartsWith. È necessario convertire l'oggetto StringBuilder in un String per queste operazioni e questo può negare il vantaggio in merito alle prestazioni dell'utilizzo di StringBuilder.You'll have to convert the StringBuilder object to a String for these operations, and this can negate the performance benefit from using StringBuilder. Per ulteriori informazioni, vedere la sezione ricerca del testo in un oggetto StringBuilder .For more information, see the Searching the text in a StringBuilder object section.

In queste condizioni, provare a usare la classe StringBuilder:Consider using the StringBuilder class under these conditions:

  • Quando si prevede che l'app effettui un numero sconosciuto di modifiche a una stringa in fase di progettazione, ad esempio quando si usa un ciclo per concatenare un numero casuale di stringhe che contengono l'input dell'utente.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).

  • Quando si prevede che l'app effettui un numero significativo di modifiche a una stringa.When you expect your app to make a significant number of changes to a string.

Funzionamento di StringBuilderHow StringBuilder works

La proprietà StringBuilder.Length indica il numero di caratteri attualmente contenuti nell'oggetto StringBuilder.The StringBuilder.Length property indicates the number of characters the StringBuilder object currently contains. Se si aggiungono caratteri all'oggetto StringBuilder, la sua lunghezza aumenta fino a quando non è uguale alla dimensione della proprietà StringBuilder.Capacity, che definisce il numero di caratteri che l'oggetto può contenere.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. Se il numero di caratteri aggiunti fa sì che la lunghezza dell'oggetto StringBuilder superi la capacità corrente, viene allocata una nuova memoria, il valore della proprietà Capacity viene raddoppiato, vengono aggiunti nuovi caratteri all'oggetto StringBuilder e la relativa proprietà Length è regolata.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 memoria aggiuntiva per l'oggetto StringBuilder viene allocata in modo dinamico fino a raggiungere il valore definito dalla proprietà StringBuilder.MaxCapacity.Additional memory for the StringBuilder object is allocated dynamically until it reaches the value defined by the StringBuilder.MaxCapacity property. Quando viene raggiunta la capacità massima, non è possibile allocare ulteriore memoria per l'oggetto StringBuilder e il tentativo di aggiungere caratteri o espanderlo oltre la capacità massima genera un'eccezione ArgumentOutOfRangeException o OutOfMemoryException.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.

Nell'esempio seguente viene illustrato il modo in cui un oggetto StringBuilder alloca la nuova memoria e aumenta la capacità in modo dinamico man mano che la stringa assegnata all'oggetto si espande.The following example illustrates how a StringBuilder object allocates new memory and increases its capacity dynamically as the string assigned to the object expands. Il codice crea un oggetto StringBuilder chiamando il costruttore predefinito (senza parametri).The code creates a StringBuilder object by calling its default (parameterless) constructor. La capacità predefinita di questo oggetto è di 16 caratteri e la capacità massima è superiore a 2 miliardi caratteri.The default capacity of this object is 16 characters, and its maximum capacity is more than 2 billion characters. Aggiunta della stringa "This is a frase".Appending the string "This is a sentence." genera una nuova allocazione di memoria perché la lunghezza della stringa (19 caratteri) supera la capacità predefinita dell'oggetto StringBuilder.results in a new memory allocation because the string length (19 characters) exceeds the default capacity of the StringBuilder object. La capacità dell'oggetto raddoppia a 32 caratteri, viene aggiunta la nuova stringa e la lunghezza dell'oggetto ora è uguale a 19 caratteri.The capacity of the object doubles to 32 characters, the new string is added, and the length of the object now equals 19 characters. Il codice aggiunge quindi la stringa "Questa è una frase aggiuntiva".The code then appends the string "This is an additional sentence." al valore dell'oggetto StringBuilder 11 volte.to the value of the StringBuilder object 11 times. Ogni volta che l'operazione di Accodamento fa sì che la lunghezza dell'oggetto StringBuilder superi la capacità, la capacità esistente viene raddoppiata e l'operazione di Append ha esito positivo.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

Allocazione di memoriaMemory allocation

La capacità predefinita di un oggetto StringBuilder è di 16 caratteri e la capacità massima predefinita è Int32.MaxValue.The default capacity of a StringBuilder object is 16 characters, and its default maximum capacity is Int32.MaxValue. Questi valori predefiniti vengono utilizzati se si chiamano i costruttori StringBuilder() e StringBuilder(String).These default values are used if you call the StringBuilder() and StringBuilder(String) constructors.

È possibile definire in modo esplicito la capacità iniziale di un oggetto StringBuilder nei modi seguenti:You can explicitly define the initial capacity of a StringBuilder object in the following ways:

  • Chiamando uno dei costruttori di StringBuilder che include un parametro di capacity quando si crea l'oggetto.By calling any of the StringBuilder constructors that includes a capacity parameter when you create the object.

  • Assegnando in modo esplicito un nuovo valore alla proprietà StringBuilder.Capacity per espandere un oggetto StringBuilder esistente.By explicitly assigning a new value to the StringBuilder.Capacity property to expand an existing StringBuilder object. Si noti che la proprietà genera un'eccezione se la nuova capacità è minore della capacità esistente o maggiore della capacità massima dell'oggetto StringBuilder.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.

  • Chiamando il metodo StringBuilder.EnsureCapacity con la nuova capacità.By calling the StringBuilder.EnsureCapacity method with the new capacity. La nuova capacità non deve essere maggiore della capacità massima dell'oggetto StringBuilder.The new capacity must not be greater than the StringBuilder object's maximum capacity. Tuttavia, a differenza di un'assegnazione alla proprietà Capacity, EnsureCapacity non genera un'eccezione se la nuova capacità desiderata è inferiore alla capacità esistente; in questo caso, la chiamata al metodo non ha alcun effetto.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.

Se la lunghezza della stringa assegnata all'oggetto StringBuilder nella chiamata del costruttore supera la capacità predefinita o la capacità specificata, la proprietà Capacity viene impostata sulla lunghezza della stringa specificata con il parametro value.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.

È possibile definire in modo esplicito la capacità massima di un oggetto StringBuilder chiamando il costruttore di StringBuilder(Int32, Int32).You can explicitly define the maximum capacity of a StringBuilder object by calling the StringBuilder(Int32, Int32) constructor. Non è possibile modificare la capacità massima assegnando un nuovo valore alla proprietà MaxCapacity perché è di sola lettura.You can't change the maximum capacity by assigning a new value to the MaxCapacity property, because it is read-only.

Come illustrato nella sezione precedente, ogni volta che la capacità esistente non è adeguata, viene allocata ulteriore memoria e la capacità di un oggetto StringBuilder raddoppia fino al valore definito dalla proprietà MaxCapacity.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.

In generale, la capacità predefinita e la capacità massima sono appropriate per la maggior parte delle app.In general, the default capacity and maximum capacity are adequate for most apps. È possibile considerare l'impostazione di questi valori nelle condizioni seguenti:You might consider setting these values under the following conditions:

  • Se è probabile che le dimensioni finali dell'oggetto StringBuilder aumentino in modo estremamente elevato, in genere in eccesso di diversi megabyte.If the eventual size of the StringBuilder object is likely to grow exceedingly large, typically in excess of several megabytes. In questo caso, è possibile che si verifichi un vantaggio in merito alle prestazioni impostando la proprietà Capacity iniziale su un valore significativamente elevato per eliminare la necessità di un numero eccessivo di riallocazioni di memoria.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.

  • Se l'app è in esecuzione in un sistema con memoria limitata.If your app is running on a system with limited memory. In questo caso, è consigliabile impostare la proprietà MaxCapacity su un valore minore di Int32.MaxValue se l'app gestisce stringhe di grandi dimensioni che possono causare l'esecuzione in un ambiente con vincoli di memoria.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.

Creazione di un'istanza di un oggetto StringBuilderInstantiating a StringBuilder object

Si crea un'istanza di un oggetto StringBuilder chiamando uno dei sei costruttori della classe di overload, elencati nella tabella seguente.You instantiate a StringBuilder object by calling one of its six overloaded class constructors, which are listed in the following table. Tre dei costruttori creano un'istanza di un oggetto StringBuilder il cui valore è una stringa vuota, ma ne imposta i valori Capacity e MaxCapacity in modo diverso.Three of the constructors instantiate a StringBuilder object whose value is an empty string, but set its Capacity and MaxCapacity values differently. I restanti tre costruttori definiscono un oggetto StringBuilder con un valore di stringa e una capacità specifici.The remaining three constructors define a StringBuilder object that has a specific string value and capacity. Due dei tre costruttori utilizzano la capacità massima predefinita di Int32.MaxValue, mentre la terza consente di impostare la capacità massima.Two of the three constructors use the default maximum capacity of Int32.MaxValue, whereas the third allows you to set the maximum capacity.

CostruttoreConstructor Valore stringaString value CapacitàCapacity Capacità massimaMaximum capacity
StringBuilder() String.Empty 1616 Int32.MaxValue
StringBuilder(Int32) String.Empty Definito dal parametro capacityDefined by the capacity parameter Int32.MaxValue
StringBuilder(Int32, Int32) String.Empty Definito dal parametro capacityDefined by the capacity parameter Definito dal parametro maxCapacityDefined by the maxCapacity parameter
StringBuilder(String) Definito dal parametro valueDefined by the value parameter 16 o value.16 or value. Length, a seconda del valore maggioreLength, whichever is greater Int32.MaxValue
StringBuilder(String, Int32) Definito dal parametro valueDefined by the value parameter Definito dal parametro capacity o value.Defined by the capacity parameter or value. Length, a seconda del valore maggiore.Length, whichever is greater. Int32.MaxValue
StringBuilder(String, Int32, Int32, Int32) definito da value.Defined by value. Substring(startIndex, length)Substring(startIndex, length) Definito dal parametro capacity o value.Defined by the capacity parameter or value. Length, a seconda del valore maggiore.Length, whichever is greater. Definito dal parametro maxCapacityDefined by the maxCapacity parameter

Nell'esempio seguente vengono utilizzati tre overload del costruttore per creare un'istanza di oggetti StringBuilder.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

Chiamata di metodi StringBuilderCalling StringBuilder methods

La maggior parte dei metodi che modificano la stringa in un'istanza di StringBuilder restituisce un riferimento alla stessa istanza.Most of the methods that modify the string in a StringBuilder instance return a reference to that same instance. In questo modo è possibile chiamare StringBuilder metodi in due modi:This enables you to call StringBuilder methods in two ways:

  • È possibile effettuare chiamate a singoli metodi e ignorare il valore restituito, come nell'esempio seguente.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.
    
  • È possibile eseguire una serie di chiamate al metodo in un'unica istruzione.You can make a series of method calls in a single statement. Questa operazione può essere utile se si desidera scrivere una singola istruzione che concatena le operazioni successive.This can be convenient if you want to write a single statement that chains successive operations. Nell'esempio seguente vengono consolidate tre chiamate al metodo dell'esempio precedente in una sola riga di codice.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.
    

Esecuzione di operazioni StringBuilderPerforming StringBuilder operations

È possibile usare i metodi della classe StringBuilder per eseguire un'iterazione, aggiungere, eliminare o modificare i caratteri in un oggetto StringBuilder.You can use the methods of the StringBuilder class to iterate, add, delete, or modify characters in a StringBuilder object.

Iterazione di caratteri StringBuilderIterating StringBuilder characters

È possibile accedere ai caratteri in un oggetto StringBuilder usando la proprietà StringBuilder.Chars[Int32].You can access the characters in a StringBuilder object by using the StringBuilder.Chars[Int32] property. In C#Chars[Int32] è un indicizzatore; in Visual Basic, si tratta della proprietà predefinita della classe StringBuilder.In C#, Chars[Int32] is an indexer; in Visual Basic, it is the default property of the StringBuilder class. In questo modo è possibile impostare o recuperare singoli caratteri utilizzando solo l'indice, senza fare riferimento in modo esplicito alla proprietà Chars[Int32].This enables you to set or retrieve individual characters by using their index only, without explicitly referencing the Chars[Int32] property. I caratteri in un oggetto StringBuilder iniziano in corrispondenza dell'indice 0 (zero) e continuano a indicizzare Length-1.Characters in a StringBuilder object begin at index 0 (zero) and continue to index Length - 1.

Nell'esempio seguente viene illustrata la proprietà Chars[Int32].The following example illustrates the Chars[Int32] property. Aggiunge dieci numeri casuali a un oggetto StringBuilder e quindi scorre ogni carattere.It appends ten random numbers to a StringBuilder object, and then iterates each character. Se la categoria Unicode del carattere è UnicodeCategory.DecimalDigitNumber, diminuisce il numero di 1 (o modifica il numero in 9 se il valore è 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). Nell'esempio viene visualizzato il contenuto dell'oggetto StringBuilder sia prima che dopo la modifica dei valori dei singoli caratteri.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'uso dell'indicizzazione basata sui caratteri con la proprietà Chars[Int32] può essere lentissimo nelle condizioni seguenti:Using character-based indexing with the Chars[Int32] property can be extremely slow under the following conditions:

L'impatto sulle prestazioni è notevole poiché ogni accesso ai caratteri scorre l'intero elenco di blocchi collegato per trovare il buffer corretto in cui eseguire l'indicizzazione.Performance is severely impacted because each character access walks the entire linked list of chunks to find the correct buffer to index into.

Nota

Nel caso di un oggetto StringBuilder "pesante" e di grandi dimensioni, usare la proprietà Chars[Int32] per eseguire l'accesso basato su indice a uno o un numero limitato di caratteri ha un impatto trascurabile sulle prestazioni, in genere è un'operazione 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. L'impatto significativo sulle prestazioni si verifica durante l'iterazione dei caratteri nell'oggetto StringBuilder, che è un'operazione O(n^2) .The significant performance impact occurs when iterating the characters in the StringBuilder object, which is an O(n^2) operation.

Se si verificano problemi di prestazioni quando si usa l'indicizzazione basata su caratteri con gli oggetti StringBuilder, è possibile adottare una delle seguenti soluzioni alternative:If you encounter performance issues when using character-based indexing with StringBuilder objects, you can use any of the following workarounds:

  • Convertire l'istanza StringBuilder in un String chiamando il metodo ToString, quindi accedere ai caratteri nella stringa.Convert the StringBuilder instance to a String by calling the ToString method, then access the characters in the string.

  • Copiare il contenuto dell'oggetto StringBuilder esistente in un nuovo oggetto StringBuilder con dimensioni preimpostate.Copy the contents of the existing StringBuilder object to a new pre-sized StringBuilder object. Le prestazioni migliorano perché il nuovo oggetto StringBuilder non è pesante.Performance improves because the new StringBuilder object is not chunky. Ad esempio: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)
    
  • Impostare la capacità iniziale dell'oggetto StringBuilder su un valore approssimativamente uguale alle dimensioni massime previste chiamando il costruttore 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. Si noti che in questo modo viene allocato l'intero di memoria anche se StringBuilder raramente raggiunge la capacità massima.Note that this allocates the entire block of memory even if the StringBuilder rarely reaches its maximum capacity.

Aggiunta di testo a un oggetto StringBuilderAdding text to a StringBuilder object

La classe StringBuilder include i metodi seguenti per espandere il contenuto di un oggetto StringBuilder:The StringBuilder class includes the following methods for expanding the contents of a StringBuilder object:

  • Il metodo Append aggiunge una stringa, una sottostringa, una matrice di caratteri, una parte di una matrice di caratteri, un singolo carattere ripetuto più volte o la rappresentazione di stringa di un tipo di dati primitivo a un oggetto StringBuilder.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.

  • Il metodo AppendLine aggiunge un terminatore di riga o una stringa insieme a un terminatore di riga a un oggetto StringBuilder.The AppendLine method appends a line terminator or a string along with a line terminator to a StringBuilder object.

  • Il metodo AppendFormat aggiunge una stringa di formato composito a un oggetto StringBuilder.The AppendFormat method appends a composite format string to a StringBuilder object. Le rappresentazioni di stringa degli oggetti inclusi nella stringa di risultato possono riflettere le convenzioni di formattazione delle impostazioni cultura correnti del sistema o le impostazioni cultura specificate.The string representations of objects included in the result string can reflect the formatting conventions of the current system culture or a specified culture.

  • Il metodo Insert inserisce una stringa, una sottostringa, più ripetizioni di una stringa, una matrice di caratteri, una parte di una matrice di caratteri o la rappresentazione di stringa di un tipo di dati primitivo in una posizione specificata nell'oggetto StringBuilder.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 posizione è definita da un indice in base zero.The position is defined by a zero-based index.

Nell'esempio seguente vengono usati i metodi Append, AppendLine, AppendFormate Insert per espandere il testo di un oggetto StringBuilder.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            <

Eliminazione di testo da un oggetto StringBuilderDeleting text from a StringBuilder object

La classe StringBuilder include metodi che consentono di ridurre le dimensioni dell'istanza di StringBuilder corrente.The StringBuilder class includes methods that can reduce the size of the current StringBuilder instance. Il metodo Clear rimuove tutti i caratteri e imposta la proprietà Length su zero.The Clear method removes all characters and sets the Length property to zero. Il metodo Remove Elimina un numero specificato di caratteri a partire da una posizione di indice specifica.The Remove method deletes a specified number of characters starting at a particular index position. Inoltre, è possibile rimuovere i caratteri dalla fine di un oggetto StringBuilder impostando la relativa proprietà Length su un valore minore della lunghezza dell'istanza corrente.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.

Nell'esempio seguente viene rimosso parte del testo da un oggetto StringBuilder, vengono visualizzati i valori di capacità risultante, capacità massima e lunghezza, quindi viene chiamato il metodo Clear per rimuovere tutti i caratteri dall'oggetto StringBuilder.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

Modifica del testo in un oggetto StringBuilderModifying the text in a StringBuilder object

Il metodo StringBuilder.Replace sostituisce tutte le occorrenze di un carattere o di una stringa nell'intero oggetto StringBuilder o in un intervallo di caratteri specifico.The StringBuilder.Replace method replaces all occurrences of a character or a string in the entire StringBuilder object or in a particular character range. Nell'esempio seguente viene usato il metodo Replace per sostituire tutti i punti esclamativi (!) con i punti interrogativi (?) nell'oggetto StringBuilder.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?

Ricerca del testo in un oggetto StringBuilderSearching the text in a StringBuilder object

La classe StringBuilder non include metodi simili ai metodi String.Contains, String.IndexOfe String.StartsWith forniti dalla classe String, che consentono di eseguire ricerche nell'oggetto per un particolare carattere o una sottostringa.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. Per determinare la presenza o la posizione del carattere iniziale di una sottostringa è necessario eseguire la ricerca di un valore String usando un metodo di ricerca di stringhe o un metodo di espressione regolare.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. Sono disponibili quattro modi per implementare tali ricerche, come illustrato nella tabella seguente.There are four ways to implement such searches, as the following table shows.

TecnicaTechnique VantaggiPros SvantaggiCons
Cerca i valori stringa prima di aggiungerli all'oggetto StringBuilder.Search string values before adding them to the StringBuilder object. Utile per determinare se esiste una sottostringa.Useful for determining whether a substring exists. Non può essere utilizzato quando la posizione di indice di una sottostringa è importante.Cannot be used when the index position of a substring is important.
Chiamare ToString e cercare l'oggetto String restituito.Call ToString and search the returned String object. Facile da usare se si assegna tutto il testo a un oggetto StringBuilder e quindi si inizia a modificarlo.Easy to use if you assign all the text to a StringBuilder object, and then begin to modify it. Complessa per chiamare ripetutamente ToString se è necessario apportare modifiche prima che tutto il testo venga aggiunto all'oggetto StringBuilder.Cumbersome to repeatedly call ToString if you must make modifications before all text is added to the StringBuilder object.

Se si stanno apportando modifiche, è necessario ricordarsi di lavorare dalla fine del testo dell'oggetto StringBuilder.You must remember to work from the end of the StringBuilder object's text if you're making changes.
Utilizzare la proprietà Chars[Int32] per eseguire una ricerca sequenziale in un intervallo di caratteri.Use the Chars[Int32] property to sequentially search a range of characters. Utile se si è interessati a singoli caratteri o a una sottostringa di piccole dimensioni.Useful if you're concerned with individual characters or a small substring. Complesso se il numero di caratteri da cercare è elevato o se la logica di ricerca è complessa.Cumbersome if the number of characters to search is large or if the search logic is complex.

Comporta una riduzione delle prestazioni per gli oggetti che sono aumentati in modo molto elevato mediante chiamate ripetute al metodo.Results in very poor performance for objects that have grown very large through repeated method calls.
Converte l'oggetto StringBuilder in un oggetto String ed esegue modifiche nell'oggetto String.Convert the StringBuilder object to a String object, and perform modifications on the String object. Utile se il numero di modifiche è ridotto.Useful if the number of modifications is small. Nega i vantaggi a livello di prestazioni della classe StringBuilder se il numero di modifiche è elevato.Negates the performance benefit of the StringBuilder class if the number of modifications is large.

Esaminiamo queste tecniche in modo più dettagliato.Let's examine these techniques in greater detail.

  • Se l'obiettivo della ricerca è determinare se una determinata sottostringa esiste, ovvero se non si è interessati alla posizione della sottostringa, è possibile cercare le stringhe prima di archiviarle nell'oggetto StringBuilder.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. Nell'esempio seguente viene fornita una possibile implementazione.The following example provides one possible implementation. Definisce una classe StringBuilderFinder il cui costruttore viene passato un riferimento a un oggetto StringBuilder e la sottostringa da trovare nella stringa.It defines a StringBuilderFinder class whose constructor is passed a reference to a StringBuilder object and the substring to find in the string. In questo caso, l'esempio tenta di determinare se le temperature registrate sono in gradi Fahrenheit o Celsius e aggiunge il testo introduttivo appropriato all'inizio dell'oggetto StringBuilder.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 generatore di numeri casuali viene usato per selezionare una matrice che contiene dati in gradi Celsius o gradi 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
    
  • Chiamare il metodo StringBuilder.ToString per convertire l'oggetto StringBuilder in un oggetto String.Call the StringBuilder.ToString method to convert the StringBuilder object to a String object. È possibile eseguire ricerche nella stringa utilizzando metodi quali String.LastIndexOf o String.StartsWith, oppure è possibile utilizzare espressioni regolari e la classe Regex per la ricerca di modelli.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. Poiché gli oggetti StringBuilder e String utilizzano la codifica UTF-16 per archiviare i caratteri, le posizioni di indice di caratteri, sottostringhe e corrispondenze di espressioni regolari sono le stesse in entrambi gli oggetti.Because 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. In questo modo è possibile utilizzare StringBuilder metodi per apportare modifiche nella stessa posizione in cui il testo viene trovato nell'oggetto String.This enables you to use StringBuilder methods to make changes at the same position at which that text is found in the String object.

    Nota

    Se si adotta questo approccio, è opportuno lavorare dalla fine dell'oggetto StringBuilder all'inizio, in modo da non dover convertire ripetutamente l'oggetto StringBuilder in una stringa.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.

    Questo approccio viene illustrato nell'esempio seguente:The following example illustrates this approach. Archivia quattro occorrenze di ogni lettera dell'alfabeto inglese in un oggetto StringBuilder.It stores four occurrences of each letter of the English alphabet in a StringBuilder object. Converte quindi il testo in un oggetto String e usa un'espressione regolare per identificare la posizione iniziale di ogni sequenza di quattro caratteri.It then converts the text to a String object and uses a regular expression to identify the starting position of each four-character sequence. Infine, viene aggiunto un carattere di sottolineatura prima di ogni sequenza di quattro caratteri ad eccezione della prima sequenza e il primo carattere della sequenza viene convertito in maiuscolo.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
    
  • Utilizzare la proprietà StringBuilder.Chars[Int32] per eseguire una ricerca sequenziale di un intervallo di caratteri in un oggetto StringBuilder.Use the StringBuilder.Chars[Int32] property to sequentially search a range of characters in a StringBuilder object. Questo approccio potrebbe non essere pratico se il numero di caratteri da cercare è elevato o se la logica di ricerca è particolarmente complessa.This approach may not be practical if the number of characters to be searched is large or the search logic is particularly complex. Per le implicazioni relative alle prestazioni dell'accesso basato su indice carattere per carattere per oggetti di StringBuilder di dimensioni molto grandi, vedere la documentazione relativa alla proprietà StringBuilder.Chars[Int32].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.

    Nell'esempio seguente la funzionalità è identica a quella dell'esempio precedente, ma è diversa nell'implementazione.The following example is identical in functionality to the previous example but differs in implementation. Usa la proprietà Chars[Int32] per rilevare quando un valore di un carattere è stato modificato, inserisce un carattere di sottolineatura in tale posizione e converte il primo carattere nella nuova sequenza in maiuscolo.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
    
  • Archiviare tutto il testo non modificato nell'oggetto StringBuilder, chiamare il metodo StringBuilder.ToString per convertire l'oggetto StringBuilder in un oggetto String ed eseguire le modifiche nell'oggetto String.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. È possibile utilizzare questo approccio se si dispone solo di poche modifiche; in caso contrario, il costo dell'utilizzo di stringhe non modificabili può negare i vantaggi in termini di prestazioni derivanti dall'utilizzo di un oggetto StringBuilder.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.

    Nell'esempio seguente la funzionalità è identica a quella dei due esempi precedenti, ma è diversa nell'implementazione.The following example is identical in functionality to the previous two examples but differs in implementation. Crea un oggetto StringBuilder, lo converte in un oggetto String, quindi usa un'espressione regolare per eseguire tutte le modifiche rimanenti sulla stringa.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. Il metodo Regex.Replace(String, String, MatchEvaluator) usa un'espressione lambda per eseguire la sostituzione per ogni corrispondenza.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
    

Conversione dell'oggetto StringBuilder in una stringaConverting the StringBuilder object to a string

È necessario convertire l'oggetto StringBuilder in un oggetto String prima di poter passare la stringa rappresentata dall'oggetto StringBuilder a un metodo che contiene un parametro String o per visualizzarlo nell'interfaccia utente.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. Questa conversione viene eseguita chiamando il metodo StringBuilder.ToString.You perform this conversion by calling the StringBuilder.ToString method. Per un'illustrazione, vedere l'esempio precedente, che chiama il metodo ToString per convertire un oggetto StringBuilder in una stringa in modo che possa essere passato a un metodo di espressione regolare.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.

Note per i chiamanti

In .NET Core e in .NET Framework 4,0 e versioni successive, quando si crea un'istanza dell'oggetto StringBuilder chiamando il costruttore StringBuilder(Int32, Int32), la lunghezza e la capacità dell'istanza di StringBuilder possono superare il valore della relativa proprietà di MaxCapacity.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. Questa situazione può verificarsi in particolare quando si chiamano i metodi Append(String) e AppendFormat(String, Object) per aggiungere stringhe di piccole dimensioni.This can occur particularly when you call the Append(String) and AppendFormat(String, Object) methods to append small strings.

Costruttori

StringBuilder()

Inizializza una nuova istanza della classe StringBuilder.Initializes a new instance of the StringBuilder class.

StringBuilder(Int32)

Inizializza una nuova istanza della classe StringBuilder usando la capacità specificata.Initializes a new instance of the StringBuilder class using the specified capacity.

StringBuilder(Int32, Int32)

Inizializza una nuova istanza della classe StringBuilder che inizia con una capacità specificata e può raggiungere un valore massimo specificato.Initializes a new instance of the StringBuilder class that starts with a specified capacity and can grow to a specified maximum.

StringBuilder(String)

Inizializza una nuova istanza della classe StringBuilder usando la stringa specificata.Initializes a new instance of the StringBuilder class using the specified string.

StringBuilder(String, Int32)

Inizializza una nuova istanza della classe StringBuilder usando la stringa e la capacità specificate.Initializes a new instance of the StringBuilder class using the specified string and capacity.

StringBuilder(String, Int32, Int32, Int32)

Inizializza una nuova istanza della classe StringBuilder dalla sottostringa e la capacità specificate.Initializes a new instance of the StringBuilder class from the specified substring and capacity.

Proprietà

Capacity

Ottiene o imposta il numero massimo di caratteri che possono essere contenuti nella memoria allocata dall'istanza corrente.Gets or sets the maximum number of characters that can be contained in the memory allocated by the current instance.

Chars[Int32]

Ottiene o imposta il carattere nella posizione del carattere specificata in questa istanza.Gets or sets the character at the specified character position in this instance.

Length

Ottiene o imposta la lunghezza dell'oggetto StringBuilder corrente.Gets or sets the length of the current StringBuilder object.

MaxCapacity

Ottiene la capacità massima di questa istanza.Gets the maximum capacity of this instance.

Metodi

Append(Boolean)

Accoda la rappresentazione di stringa di un valore booleano specificato a questa istanza.Appends the string representation of a specified Boolean value to this instance.

Append(Byte)

Accoda la rappresentazione di stringa di un intero senza segno a 8 bit specificato a questa istanza.Appends the string representation of a specified 8-bit unsigned integer to this instance.

Append(Char)

Accoda la rappresentazione di stringa di un oggetto Char specificato a questa istanza.Appends the string representation of a specified Char object to this instance.

Append(Char*, Int32)

Accoda a questa istanza una matrice di caratteri Unicode a partire da un indirizzo specificato.Appends an array of Unicode characters starting at a specified address to this instance.

Append(Char, Int32)

Accoda un numero specificato di copie della rappresentazione di stringa di un carattere Unicode a questa istanza.Appends a specified number of copies of the string representation of a Unicode character to this instance.

Append(Char[])

Accoda la rappresentazione di stringa dei caratteri Unicode in una matrice specificata a questa istanza.Appends the string representation of the Unicode characters in a specified array to this instance.

Append(Char[], Int32, Int32)

Accoda la rappresentazione di stringa di una sottomatrice specificata di caratteri Unicode a questa istanza.Appends the string representation of a specified subarray of Unicode characters to this instance.

Append(Decimal)

Accoda la rappresentazione di stringa di un numero decimale specificato a questa istanza.Appends the string representation of a specified decimal number to this instance.

Append(Double)

Accoda la rappresentazione di stringa di un numero a virgola mobile e precisione doppia specificato a questa istanza.Appends the string representation of a specified double-precision floating-point number to this instance.

Append(Int16)

Accoda la rappresentazione di stringa di un intero con segno a 16 bit specificato a questa istanza.Appends the string representation of a specified 16-bit signed integer to this instance.

Append(Int32)

Accoda la rappresentazione di stringa di un intero con segno a 32 bit specificato a questa istanza.Appends the string representation of a specified 32-bit signed integer to this instance.

Append(Int64)

Accoda la rappresentazione di stringa di un intero con segno a 64 bit specificato a questa istanza.Appends the string representation of a specified 64-bit signed integer to this instance.

Append(Object)

Accoda la rappresentazione di stringa di un oggetto specificato a questa istanza.Appends the string representation of a specified object to this instance.

Append(ReadOnlyMemory<Char>)

Accoda a questa istanza la rappresentazione stringa di un'area di memoria dei caratteri di sola lettura specificata.Appends the string representation of a specified read-only character memory region to this instance.

Append(ReadOnlySpan<Char>)

Accoda a questa istanza la rappresentazione stringa di un intervallo di caratteri di sola lettura specificato.Appends the string representation of a specified read-only character span to this instance.

Append(SByte)

Accoda la rappresentazione di stringa di un intero con segno a 8 bit specificato a questa istanza.Appends the string representation of a specified 8-bit signed integer to this instance.

Append(Single)

Accoda la rappresentazione di stringa di un numero a virgola mobile a precisione singola specificato a questa istanza.Appends the string representation of a specified single-precision floating-point number to this instance.

Append(String)

Accoda una copia della stringa specificata a questa istanza.Appends a copy of the specified string to this instance.

Append(String, Int32, Int32)

Accoda una copia della sottostringa specificata a questa istanza.Appends a copy of a specified substring to this instance.

Append(StringBuilder)

Accoda la rappresentazione stringa di un generatore di stringhe specificato a questa istanza.Appends the string representation of a specified string builder to this instance.

Append(StringBuilder, Int32, Int32)

Accoda a questa istanza una copia di una sottostringa all'interno di un generatore di stringhe specificato.Appends a copy of a substring within a specified string builder to this instance.

Append(UInt16)

Accoda la rappresentazione di stringa di un intero senza segno a 16 bit specificato a questa istanza.Appends the string representation of a specified 16-bit unsigned integer to this instance.

Append(UInt32)

Accoda la rappresentazione di stringa di un intero senza segno a 32 bit specificato a questa istanza.Appends the string representation of a specified 32-bit unsigned integer to this instance.

Append(UInt64)

Accoda la rappresentazione di stringa di un intero senza segno a 64 bit specificato a questa istanza.Appends the string representation of a specified 64-bit unsigned integer to this instance.

AppendFormat(IFormatProvider, String, Object)

Accoda la stringa restituita dall'elaborazione di una stringa in formato composito, che contiene zero o più elementi di formato, a questa istanza.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Ogni elemento di formato viene sostituito dalla rappresentazione di stringa di un singolo argomento usando un provider del formato specificato.Each format item is replaced by the string representation of a single argument using a specified format provider.

AppendFormat(IFormatProvider, String, Object, Object)

Accoda la stringa restituita dall'elaborazione di una stringa in formato composito, che contiene zero o più elementi di formato, a questa istanza.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Ogni elemento di formato viene sostituito dalla rappresentazione di stringa di uno di due argomenti usando un provider del formato specificato.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)

Accoda la stringa restituita dall'elaborazione di una stringa in formato composito, che contiene zero o più elementi di formato, a questa istanza.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Ogni elemento di formato viene sostituito dalla rappresentazione di stringa di uno di tre argomenti usando un provider del formato specificato.Each format item is replaced by the string representation of either of three arguments using a specified format provider.

AppendFormat(IFormatProvider, String, Object[])

Accoda la stringa restituita dall'elaborazione di una stringa in formato composito, che contiene zero o più elementi di formato, a questa istanza.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Ogni elemento di formato viene sostituito dalla rappresentazione di stringa di un argomento corrispondente in una matrice di parametri usando un provider del formato specificato.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)

Accoda la stringa restituita dall'elaborazione di una stringa in formato composito, che contiene zero o più elementi di formato, a questa istanza.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Ogni elemento di formato viene sostituito dalla rappresentazione di stringa di un singolo argomento.Each format item is replaced by the string representation of a single argument.

AppendFormat(String, Object, Object)

Accoda la stringa restituita dall'elaborazione di una stringa in formato composito, che contiene zero o più elementi di formato, a questa istanza.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Ogni elemento di formato viene sostituito dalla rappresentazione di stringa di uno dei due argomenti.Each format item is replaced by the string representation of either of two arguments.

AppendFormat(String, Object, Object, Object)

Accoda la stringa restituita dall'elaborazione di una stringa in formato composito, che contiene zero o più elementi di formato, a questa istanza.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Ogni elemento di formato viene sostituito dalla rappresentazione di stringa di uno dei tre argomenti.Each format item is replaced by the string representation of either of three arguments.

AppendFormat(String, Object[])

Accoda la stringa restituita dall'elaborazione di una stringa in formato composito, che contiene zero o più elementi di formato, a questa istanza.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Ogni elemento di formato viene sostituito dalla rappresentazione di stringa di un argomento corrispondente in una matrice di parametri.Each format item is replaced by the string representation of a corresponding argument in a parameter array.

AppendJoin(Char, Object[])

Concatena le rappresentazioni stringa degli elementi nella matrice di oggetti fornita usando il separatore di caratteri specificato tra i membri, quindi accoda il risultato nell'istanza corrente del generatore di stringhe.Concatenates the string representations of the elements in the provided array of objects, using the specified char separator between each member, then appends the result to the current instance of the string builder.

AppendJoin(Char, String[])

Concatena le stringhe della matrice fornita usando il separatore di caratteri specificato tra ogni stringa, quindi accoda il risultato nell'istanza corrente del generatore di stringhe.Concatenates the strings of the provided array, using the specified char separator between each string, then appends the result to the current instance of the string builder.

AppendJoin(String, Object[])

Concatena le rappresentazioni stringa degli elementi nella matrice di oggetti fornita usando il separatore specificato tra i membri, quindi accoda il risultato nell'istanza corrente del generatore di stringhe.Concatenates the string representations of the elements in the provided array of objects, using the specified separator between each member, then appends the result to the current instance of the string builder.

AppendJoin(String, String[])

Concatena le stringhe della matrice fornita usando il separatore specificato tra ogni stringa, quindi accoda il risultato nell'istanza corrente del generatore di stringhe.Concatenates the strings of the provided array, using the specified separator between each string, then appends the result to the current instance of the string builder.

AppendJoin<T>(Char, IEnumerable<T>)

Concatena e accoda i membri di una raccolta usando il separatore di caratteri specificato tra i membri.Concatenates and appends the members of a collection, using the specified char separator between each member.

AppendJoin<T>(String, IEnumerable<T>)

Concatena e accoda i membri di una raccolta usando il separatore specificato tra i membri.Concatenates and appends the members of a collection, using the specified separator between each member.

AppendLine()

Accoda il terminatore di riga predefinito alla fine dell'oggetto StringBuilder corrente.Appends the default line terminator to the end of the current StringBuilder object.

AppendLine(String)

Accoda una copia della stringa specificata seguita dal terminatore di riga predefinito alla fine dell'oggetto StringBuilder corrente.Appends a copy of the specified string followed by the default line terminator to the end of the current StringBuilder object.

Clear()

Rimuove tutti i caratteri dall'istanza di StringBuilder corrente.Removes all characters from the current StringBuilder instance.

CopyTo(Int32, Char[], Int32, Int32)

Copia i caratteri da un segmento specificato di questa istanza a un segmento specificato di una matrice Char di destinazione.Copies the characters from a specified segment of this instance to a specified segment of a destination Char array.

CopyTo(Int32, Span<Char>, Int32)

Copia i caratteri da un segmento specificato di questa istanza a un intervallo Char di destinazione.Copies the characters from a specified segment of this instance to a destination Char span.

EnsureCapacity(Int32)

Garantisce che la capacità di questa istanza di StringBuilder corrisponda almeno al valore specificato.Ensures that the capacity of this instance of StringBuilder is at least the specified value.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
Equals(ReadOnlySpan<Char>)

Restituisce un valore che indica se i caratteri in questa istanza sono uguali ai caratteri in un intervallo di caratteri specificato di sola lettura.Returns a value indicating whether the characters in this instance are equal to the characters in a specified read-only character span.

Equals(StringBuilder)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.Returns a value indicating whether this instance is equal to a specified object.

GetChunks()

Restituisce un oggetto che può essere usato per scorrere i blocchi di caratteri rappresentati in un ReadOnlyMemory<Char> creato da questa istanza di 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()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
Insert(Int32, Boolean)

Inserisce la rappresentazione di stringa di un valore booleano in questa istanza nella posizione del carattere specificata.Inserts the string representation of a Boolean value into this instance at the specified character position.

Insert(Int32, Byte)

Inserisce la rappresentazione di stringa di un intero senza segno a 8 bit specificato in questa istanza nella posizione del carattere specificata.Inserts the string representation of a specified 8-bit unsigned integer into this instance at the specified character position.

Insert(Int32, Char)

Inserisce la rappresentazione di stringa di un carattere Unicode specificato in questa istanza nella posizione del carattere specificata.Inserts the string representation of a specified Unicode character into this instance at the specified character position.

Insert(Int32, Char[])

Inserisce la rappresentazione di stringa di una matrice specificata di caratteri Unicode in questa istanza nella posizione del carattere specificata.Inserts the string representation of a specified array of Unicode characters into this instance at the specified character position.

Insert(Int32, Char[], Int32, Int32)

Inserisce la rappresentazione di stringa di una sottomatrice specificata di caratteri Unicode in questa istanza nella posizione del carattere specificata.Inserts the string representation of a specified subarray of Unicode characters into this instance at the specified character position.

Insert(Int32, Decimal)

Inserisce la rappresentazione di stringa di un numero decimale in questa istanza nella posizione del carattere specificata.Inserts the string representation of a decimal number into this instance at the specified character position.

Insert(Int32, Double)

Inserisce la rappresentazione di stringa di un numero a virgola mobile a precisione doppia in questa istanza nella posizione del carattere specificata.Inserts the string representation of a double-precision floating-point number into this instance at the specified character position.

Insert(Int32, Int16)

Inserisce la rappresentazione di stringa di un intero con segno a 16 bit specificato in questa istanza nella posizione del carattere specificata.Inserts the string representation of a specified 16-bit signed integer into this instance at the specified character position.

Insert(Int32, Int32)

Inserisce la rappresentazione di stringa di un intero con segno a 32 bit specificato in questa istanza nella posizione del carattere specificata.Inserts the string representation of a specified 32-bit signed integer into this instance at the specified character position.

Insert(Int32, Int64)

Inserisce la rappresentazione di stringa di un intero con segno a 64 bit in questa istanza nella posizione del carattere specificata.Inserts the string representation of a 64-bit signed integer into this instance at the specified character position.

Insert(Int32, Object)

Inserisce la rappresentazione di stringa di un oggetto in questa istanza nella posizione del carattere specificata.Inserts the string representation of an object into this instance at the specified character position.

Insert(Int32, ReadOnlySpan<Char>)

Inserisce la sequenza di caratteri in questa istanza nella posizione del carattere specificata.Inserts the sequence of characters into this instance at the specified character position.

Insert(Int32, SByte)

Inserisce la rappresentazione di stringa di un intero con segno a 8 bit specificato in questa istanza nella posizione del carattere specificata.Inserts the string representation of a specified 8-bit signed integer into this instance at the specified character position.

Insert(Int32, Single)

Inserisce la rappresentazione di stringa di un numero a virgola mobile a precisione singola in questa istanza nella posizione del carattere specificata.Inserts the string representation of a single-precision floating point number into this instance at the specified character position.

Insert(Int32, String)

Inserisce una stringa in questa istanza nella posizione del carattere specificata.Inserts a string into this instance at the specified character position.

Insert(Int32, String, Int32)

Inserisce una o più copie di una stringa specificata in questa istanza nella posizione del carattere specificata.Inserts one or more copies of a specified string into this instance at the specified character position.

Insert(Int32, UInt16)

Inserisce la rappresentazione di stringa di un intero senza segno a 16 bit in questa istanza nella posizione del carattere specificata.Inserts the string representation of a 16-bit unsigned integer into this instance at the specified character position.

Insert(Int32, UInt32)

Inserisce la rappresentazione di stringa di un intero senza segno a 32 bit in questa istanza nella posizione del carattere specificata.Inserts the string representation of a 32-bit unsigned integer into this instance at the specified character position.

Insert(Int32, UInt64)

Inserisce la rappresentazione di stringa di un intero senza segno a 64 bit in questa istanza nella posizione del carattere specificata.Inserts the string representation of a 64-bit unsigned integer into this instance at the specified character position.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
Remove(Int32, Int32)

Rimuove l'intervallo di caratteri specificato da questa istanza.Removes the specified range of characters from this instance.

Replace(Char, Char)

Sostituisce tutte le occorrenze di un carattere specificato in questa istanza con un altro carattere specificato.Replaces all occurrences of a specified character in this instance with another specified character.

Replace(Char, Char, Int32, Int32)

Sostituisce tutte le occorrenze di un carattere specificato in una sottostringa di questa istanza con un altro carattere specificato.Replaces, within a substring of this instance, all occurrences of a specified character with another specified character.

Replace(String, String)

Sostituisce tutte le occorrenze di una stringa specificata in questa istanza con un'altra stringa specificata.Replaces all occurrences of a specified string in this instance with another specified string.

Replace(String, String, Int32, Int32)

Sostituisce tutte le occorrenze di una stringa specificata in una sottostringa di questa istanza con un'altra stringa specificata.Replaces, within a substring of this instance, all occurrences of a specified string with another specified string.

ToString()

Converte il valore di questa istanza in un oggetto String.Converts the value of this instance to a String.

ToString(Int32, Int32)

Converte il valore di una sottostringa di questa istanza in un oggetto String.Converts the value of a substring of this instance to a String.

Implementazioni dell'interfaccia esplicita

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Popola un oggetto SerializationInfo con i dati necessari per deserializzare l'oggetto StringBuilder corrente.Populates a SerializationInfo object with the data necessary to deserialize the current StringBuilder object.

Si applica a

Vedi anche