StringBuilder StringBuilder StringBuilder StringBuilder Class

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à
StringBuilderStringBuilderStringBuilderStringBuilder
Attributi
Implementazioni

Esempi

Nell'esempio seguente viene illustrato come chiamare molti dei metodi definiti dal StringBuilder classe.The following example shows how to call many of the methods defined by the StringBuilder class.

using namespace System;
using namespace System::Text;

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

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

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

    // Display the number of characters in the StringBuilder
    // and its string.
    Console::WriteLine("{0} chars: {1}", sb->Length, sb->ToString());

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

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

    // Display the number of characters in the StringBuilder
    // and its string.
    Console::WriteLine("{0} chars: {1}", sb->Length, sb->ToString());
}

// This code produces the following output.
//
// 11 chars: ABCDEFGHIJk
// 21 chars: Alphabet: ABCDEFGHIJK
using System;
using System.Text;

public sealed class App 
{
    static void Main() 
    {
        // Create a StringBuilder that expects to hold 50 characters.
        // Initialize the StringBuilder with "ABC".
        StringBuilder sb = new StringBuilder("ABC", 50);

        // Append three characters (D, E, and F) to the end of the StringBuilder.
        sb.Append(new char[] { 'D', 'E', 'F' });

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

        // Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString());

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

        // Replace all lowercase k's with uppercase K's.
        sb.Replace('k', 'K');

        // Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString());
    }
}

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

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

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

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

        ' Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString())

        ' Insert a string at the beginning of the StringBuilder.
        sb.Insert(0, "Alphabet: ")

        ' Replace all lowercase k's with uppercase K's.
        sb.Replace("k", "K")

        ' Display the number of characters in the StringBuilder and its string.
        Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString())
    End Sub
End Module

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

Commenti

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

Contenuto della sezione:In this section:

I tipi String e StringBuilderThe String and StringBuilder types

Sebbene StringBuilder e String entrambi rappresentano infatti 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. Vale a dire, ogni operazione che viene visualizzato per modificare un String oggetto crea effettivamente una nuova stringa.That is, each operation that appears to modify a String object actually creates a new string.

Ad esempio, la chiamata per il String.Concat metodo nell'esempio c# seguente viene visualizzato per modificare il valore di una variabile 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. In effetti, il Concat metodo restituisce un value oggetto con un valore diverso e un indirizzo dal value oggetto 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 compilata con la /unsafe opzione del compilatore.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 la modifica delle stringhe complete (ad esempio applicazioni che modificano una stringa più volte in un ciclo), modificare ripetutamente una stringa può esatte una riduzione significativa 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'usare StringBuilder, ovvero una classe di stringa modificabile.The alternative is to use StringBuilder, which is a mutable string class. Modificabilità significa che dopo aver creata un'istanza della classe, e può essere modificato da aggiunta, rimozione, sostituzione o inserimento di caratteri.Mutability means that once an instance of the class has been created, it can be modified by appending, removing, replacing, or inserting characters. Oggetto StringBuilder oggetto mantiene un buffer per includere le espansioni nella stringa.A StringBuilder object maintains a buffer to accommodate expansions to the string. I nuovi dati vengono aggiunti al buffer se chat è disponibile. in caso contrario, viene allocato un nuovo e di dimensioni maggiori, i dati dal buffer originale vengono copiati nel nuovo buffer, e i nuovi dati viene quindi aggiunto al buffer di nuovo.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

Anche se il StringBuilder classe offre in genere prestazioni migliori rispetto al String (classe), è consigliabile non automaticamente sostituire String con StringBuilder ogni volta che 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. Prestazioni dipendono dalle dimensioni della stringa, la quantità di memoria da allocare per la nuova stringa, il sistema in cui è in esecuzione l'app e il 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. È consigliabile essere pronti a testare l'app per determinare se StringBuilder effettivamente offre un miglioramento significativo delle prestazioni.You should be prepared to test your app to determine whether StringBuilder actually offers a significant performance improvement.

È consigliabile usare il String classe in queste condizioni:Consider using the String class under these conditions:

  • Quando il numero di modifiche che verranno apportate all'app in una stringa è piccolo.When the number of changes that your app will make to a string is small. In questi casi StringBuilder potrebbe essere offerta trascurabile o alcun miglioramento delle prestazioni rispetto a 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 i valori letterali stringa.When you are performing a fixed number of concatenation operations, particularly with string literals. In questo caso, il compilatore può 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 estesa mentre si compila la stringa.When you have to perform extensive search operations while you are building your string. Il StringBuilder criteri di ricerca non dispone di classe, ad esempio IndexOf o StartsWith.The StringBuilder class lacks search methods such as IndexOf or StartsWith. È possibile convertire le StringBuilder dell'oggetto a un String per queste operazioni e questo può negare il miglioramento delle prestazioni dall'utilizzo 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 altre informazioni, vedere la ricerca il testo in un oggetto StringBuilder sezione.For more information, see the Searching the text in a StringBuilder object section.

È consigliabile usare il StringBuilder classe in queste condizioni:Consider using the StringBuilder class under these conditions:

  • Quando si prevede che l'app per rendere 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 per rendere 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

Il StringBuilder.Length proprietà indica il numero di caratteri di StringBuilder oggetto contiene attualmente.The StringBuilder.Length property indicates the number of characters the StringBuilder object currently contains. Se si aggiungono caratteri per il StringBuilder dell'oggetto, la sua lunghezza aumenta fino a quando non pari alla dimensione del StringBuilder.Capacity proprietà, che definisce il numero di caratteri che può contenere l'oggetto.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 del StringBuilder oggetto di superare le capacità corrente, la nuova memoria viene allocata, il valore del Capacity è raddoppiata proprietà, vengono aggiunti nuovi caratteri per il StringBuilder oggetto e relativo Lengthproprietà viene modificata.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. Memoria aggiuntiva per il StringBuilder oggetto viene allocato in modo dinamico finché non raggiunge il valore definito mediante il StringBuilder.MaxCapacity proprietà.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 può essere allocata nessuna ulteriore memoria per il StringBuilder oggetto e provando ad aggiungere caratteri o espanderla oltre la capacità massima genera un'eccezione un' ArgumentOutOfRangeException o un OutOfMemoryException eccezione.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 come un StringBuilder oggetto alloca nuova memoria e aumenta la capacità in modo dinamico quando si espande la stringa assegnata all'oggetto.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 StringBuilder oggetto chiamando il costruttore predefinito (senza parametri).The code creates a StringBuilder object by calling its default (parameterless) constructor. La capacità predefinita di questo oggetto è 16 caratteri e alla 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 la stringa "This is a una frase".Appending the string "This is a sentence." risultati in una nuova allocazione di memoria perché la lunghezza della stringa (19 caratteri) supera la capacità predefinita del StringBuilder oggetto.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 più di 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 "This is a una frase aggiuntiva".The code then appends the string "This is an additional sentence." il valore della StringBuilder oggetto 11 volte.to the value of the StringBuilder object 11 times. Ogni volta che l'operazione di Accodamento fa sì che la lunghezza del StringBuilder oggetto al superamento della capacità, la capacità esistente è raddoppiato negli anni e Append operazione 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 StringBuilder oggetto è 16 caratteri e alla capacità massima predefinita è Int32.MaxValue.The default capacity of a StringBuilder object is 16 characters, and its default maximum capacity is Int32.MaxValue. Vengono usati questi valori predefiniti se si chiama il StringBuilder() e StringBuilder(String) costruttori.These default values are used if you call the StringBuilder() and StringBuilder(String) constructors.

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

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

  • In modo esplicito assegnando un nuovo valore per il StringBuilder.Capacity proprietà da espandere esistente StringBuilder oggetto.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à sia inferiore a quella esistente della capacità o maggiore di StringBuilder capacità massima dell'oggetto.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 StringBuilder.EnsureCapacity metodo con la nuova capacità.By calling the StringBuilder.EnsureCapacity method with the new capacity. La nuova capacità non deve essere maggiore di StringBuilder capacità massima dell'oggetto.The new capacity must not be greater than the StringBuilder object's maximum capacity. Tuttavia, a differenza di un'assegnazione per la Capacity proprietà, EnsureCapacity non genera un'eccezione se la nuova capacità desiderate è inferiore alla capacità esistente; in questo caso, la chiamata al metodo 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 al StringBuilder oggetto nella chiamata al costruttore supera la capacità predefinita o la capacità specificata, il Capacity viene impostata per la lunghezza della stringa specificata con il value parametro.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 StringBuilder chiamando il StringBuilder(Int32, Int32) costruttore.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 per il MaxCapacity proprietà, 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.

La sezione precedente viene allocato Mostra, ogni volta che la capacità esistente è memoria insufficiente, aggiuntiva e la capacità di un StringBuilder valori Double fino al valore definito dall'oggetto il MaxCapacity proprietà.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 adeguate per la maggior parte delle app.In general, the default capacity and maximum capacity are adequate for most apps. È opportuno considerare l'impostazione di questi valori nelle condizioni seguenti:You might consider setting these values under the following conditions:

  • Se le dimensioni finali del StringBuilder oggetto condizione potrebbe diventare estremamente grande, in genere che superano 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, potrebbero esserci alcuni vantaggi nelle prestazioni dell'impostazione iniziale Capacity proprietà su un valore molto elevato per eliminare la necessità di riallocazioni un numero eccessivo 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. È possibile in questo caso, è consigliabile impostare il MaxCapacity proprietà minore Int32.MaxValue se l'app gestisce le stringhe di grandi dimensioni che possono causare l'esecuzione in un ambiente di memoria vincolata.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.

Creare un'istanza di un oggetto StringBuilderInstantiating a StringBuilder object

Crea un'istanza di un StringBuilder oggetto chiamando uno dei sei costruttori disponibili la classe di overload, che sono elencate nella tabella riportata di seguito.You instantiate a StringBuilder object by calling one of its six overloaded class constructors, which are listed in the following table. Tre dei costruttori di creare un'istanza di un StringBuilder il cui valore è una stringa vuota, ma impostare relativi Capacity e MaxCapacity valori 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 tre costruttori rimanenti definiscono un StringBuilder oggetto con un valore di stringa specifico e la capacità.The remaining three constructors define a StringBuilder object that has a specific string value and capacity. Due dei tre costruttori usano la capacità massima predefinita di Int32.MaxValue, mentre il terzo modo è possibile 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 capacity parametroDefined by the capacity parameter Int32.MaxValue
StringBuilder(Int32, Int32) String.Empty Definito dal capacity parametroDefined by the capacity parameter Definito dal maxCapacity parametroDefined by the maxCapacity parameter
StringBuilder(String) Definito dal value parametroDefined by the value parameter 16 o value.16 or value. Length, qualunque sia il maggioreLength, whichever is greater Int32.MaxValue
StringBuilder(String, Int32) Definito dal value parametroDefined by the value parameter Definita per il capacity parametro o value.Defined by the capacity parameter or value. Length, qualunque sia il maggiore.Length, whichever is greater. Int32.MaxValue
StringBuilder(String, Int32, Int32, Int32) definito da value.Defined by value. Substring(startIndex, length)Substring(startIndex, length) Definita per il capacity parametro o value.Defined by the capacity parameter or value. Length, qualunque sia il maggiore.Length, whichever is greater. Definito dal maxCapacity parametroDefined by the maxCapacity parameter

L'esempio seguente usa tre di questi overload del costruttore per creare un'istanza StringBuilder oggetti.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 di StringBuilderCalling StringBuilder methods

La maggior parte dei metodi che modificano la stringa in un StringBuilder istanza restituiscono un riferimento a quell'istanza stessa.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 al metodo singole e ignorare il valore restituito, come avviene 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 rendere una serie di chiamate al metodo in un'unica istruzione.You can make a series of method calls in a single statement. Può risultare utile se si vuole 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 consente di consolidare i tre chiamate al metodo dell'esempio precedente in una singola 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 di StringBuilderPerforming StringBuilder operations

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

L'iterazione di StringBuilder caratteriIterating StringBuilder characters

È possibile accedere ai caratteri in una StringBuilder utilizzando il StringBuilder.Chars[Int32] proprietà.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, è la proprietà predefinita del StringBuilder classe.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 i singoli caratteri usando solo l'indice senza fare riferimento in modo esplicito il Chars[Int32] proprietà.This enables you to set or retrieve individual characters by using their index only, without explicitly referencing the Chars[Int32] property. I caratteri in una StringBuilder oggetto iniziano in corrispondenza dell'indice 0 (zero) e continuare a indicizzare Length - 1.Characters in a StringBuilder object begin at index 0 (zero) and continue to index Length - 1.

Nell'esempio seguente viene illustrato il Chars[Int32] proprietà.The following example illustrates the Chars[Int32] property. Aggiunge 10 numeri casuali da un StringBuilder dell'oggetto e quindi scorre ogni carattere.It appends ten random numbers to a StringBuilder object, and then iterates each character. Se la categoria del carattere Unicode è UnicodeCategory.DecimalDigitNumber, riduce il numero da 1 (o modifica il numero a 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). L'esempio visualizza il contenuto del StringBuilder entrambi prima e dopo che sono stati modificati i valori dei singoli caratteri dell'oggetto.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

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

  • Il Append metodo aggiunge una stringa, una sottostringa, una matrice di caratteri, una parte di una matrice di caratteri, un singolo carattere ripetuto più volte, o tipo di rappresentazione di stringa di dati primitivo in un StringBuilder oggetto.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 AppendLine metodo aggiunge un terminatore di riga o una stringa con un terminatore di riga un StringBuilder oggetto.The AppendLine method appends a line terminator or a string along with a line terminator to a StringBuilder object.

  • Il AppendFormat metodo aggiunge un stringa di formato composito a un StringBuilder oggetto.The AppendFormat method appends a composite format string to a StringBuilder object. Le rappresentazioni di stringa degli oggetti incluse nella stringa di risultato possano riflettono le convenzioni di formattazione delle impostazioni cultura correnti del sistema o 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 Insert metodo inserisce una stringa, una sottostringa, più le ripetizioni di una stringa, una matrice di caratteri, una parte di una matrice di caratteri o la rappresentazione di stringa di dati primitivo digitare in una posizione specificata nel StringBuilder oggetto.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.

L'esempio seguente usa il Append, AppendLine, AppendFormat, e Insert metodi per espandere il testo di un StringBuilder oggetto.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

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

L'esempio seguente rimuove parte del testo da un StringBuilder oggetto, Visualizza le capacità risultante, la capacità massima e i valori delle proprietà di lunghezza e quindi chiama il Clear metodo per rimuovere tutti i caratteri dal StringBuilder oggetto.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

La modifica del testo in un oggetto StringBuilderModifying the text in a StringBuilder object

Il StringBuilder.Replace metodo sostituisce tutte le occorrenze di un carattere o una stringa all'interno dell'intero StringBuilder oggetto 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. L'esempio seguente usa il Replace metodo per sostituire tutti i punti esclamativi (!) con punti interrogativi (?) nel StringBuilder oggetto.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 il testo in un oggetto StringBuilderSearching the text in a StringBuilder object

Il StringBuilder classe non include metodi simili per il String.Contains, String.IndexOf, e String.StartsWith metodi forniti dal String (classe), che consentono di eseguire la ricerca l'oggetto per un determinato 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. Determinare la presenza o l'avvio di posizione del carattere di una sottostringa è necessario cercare un String valore utilizzando un metodo di ricerca di stringa 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 ProfessionistiPros SvantaggiCons
I valori di stringa di ricerca prima di aggiungerli al StringBuilder oggetto.Search string values before adding them to the StringBuilder object. È utile per la verifica dell'esistenza di 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 restituito String oggetto.Call ToString and search the returned String object. Facile da usare se si assegna a tutto il testo un StringBuilder dell'oggetto e quindi iniziare a modificarlo.Easy to use if you assign all the text to a StringBuilder object, and then begin to modify it. Complesso da chiamare ripetutamente ToString se è necessario apportare modifiche prima di tutto il testo viene aggiunto al StringBuilder oggetto.Cumbersome to repeatedly call ToString if you must make modifications before all text is added to the StringBuilder object.

È necessario ricordarsi di lavorare dalla fine del StringBuilder testo dell'oggetto se si stanno apportando le modifiche.You must remember to work from the end of the StringBuilder object's text if you're making changes.
Usare il Chars[Int32] proprietà da cercare in modo sequenziale un intervallo di caratteri.Use the Chars[Int32] property to sequentially search a range of characters. È utile se si è preoccupati con singoli caratteri o una sottostringa di piccole dimensioni.Useful if you're concerned with individual characters or a small substring. Un'operazione complessa 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.

Risultati molto una riduzione delle prestazioni per gli oggetti che hanno raggiunto la dimensione molto grande tramite chiamate al metodo ripetuta.Results in very poor performance for objects that have grown very large through repeated method calls.
Convertire le StringBuilder dell'oggetto a un String dell'oggetto e apportare modifiche nel String oggetto.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 il miglioramento delle prestazioni dei StringBuilder classe se il numero di modifiche è di grandi dimensioni.Negates the performance benefit of the StringBuilder class if the number of modifications is large.

Esaminiamo queste tecniche in maggiore dettaglio.Let's examine these techniques in greater detail.

  • Se l'obiettivo della ricerca deve determinare se una particolare sottostringa esiste (vale a dire, se non si intende la posizione della sottostringa), è possibile cercare le stringhe prima di archiviarli nel StringBuilder oggetto.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 fornisce una possibile implementazione.The following example provides one possible implementation. Definisce un StringBuilderFinder classe il cui costruttore viene passato un riferimento a un StringBuilder oggetto 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 registrate le temperature in gradi Fahrenheit o Celsius e aggiunge il testo introduttivo appropriato all'inizio del StringBuilder oggetto.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 i 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 StringBuilder.ToString metodo per convertire le StringBuilder dell'oggetto a un String oggetto.Call the StringBuilder.ToString method to convert the StringBuilder object to a String object. È possibile cercare la stringa con i metodi, ad esempio String.LastIndexOf oppure String.StartsWith, oppure è possibile usare espressioni regolari e Regex classe a 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é entrambe StringBuilder e String gli oggetti usano per archiviare caratteri, le posizioni dell'indice di caratteri, sottostringhe, la codifica UTF-16 e corrispondenze di espressioni regolari sono gli stessi 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 usare StringBuilder metodi di apportare modifiche nella stessa posizione in cui tale testo viene trovato nel String oggetto.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, dovrebbe funzionare dalla fine del StringBuilder oggetto alla sua introduzione in modo che non devi più volte convertire i StringBuilder oggetto 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 le occorrenze di ogni lettera dell'alfabeto inglese in un StringBuilder oggetto.It stores four occurrences of each letter of the English alphabet in a StringBuilder object. Viene quindi convertito il testo da un String dell'oggetto e viene utilizzata 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, aggiunge un carattere di sottolineatura prima di ogni sequenza di quattro caratteri, ad eccezione della prima sequenza e converte il primo carattere della sequenza di lettere maiuscole.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
    
  • Usare la StringBuilder.Chars[Int32] proprietà per la ricerca in modo sequenziale un intervallo di caratteri in un StringBuilder oggetto.Use the StringBuilder.Chars[Int32] property to sequentially search a range of characters in a StringBuilder object. Questo approccio potrebbe non essere pratica se il numero di caratteri da cercare è grande o 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 sulle prestazioni di accesso basati sull'indice di carattere per carattere per dimensioni molto grandi, chunked StringBuilder oggetti, vedere la documentazione per il StringBuilder.Chars[Int32] proprietà.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 ha funzionalità identico all'esempio precedente, ma presenta differenze nell'implementazione.The following example is identical in functionality to the previous example but differs in implementation. Usa il Chars[Int32] proprietà per rilevare quando un valore del carattere è stato modificato, inserisce un carattere di sottolineatura in tale posizione e converte il primo carattere nella sequenza di nuovo in lettere maiuscole.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
    
  • Store tutto il testo non modificato nella StringBuilder dell'oggetto, chiamare il StringBuilder.ToString metodo per convertire il StringBuilder dell'oggetto a un String dell'oggetto e apportare le modifiche nel String oggetto.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 usare questo approccio se si dispone solo di alcune modifiche; in caso contrario, il costo dell'uso delle stringhe non modificabile potrebbe annullare i vantaggi delle prestazioni dell'utilizzo un StringBuilder oggetto.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 ha funzionalità identico per i due esempi precedenti, ma presenta differenze nell'implementazione.The following example is identical in functionality to the previous two examples but differs in implementation. Crea una StringBuilder dell'oggetto, lo converte in un String dell'oggetto e quindi utilizza un'espressione regolare per eseguire tutte le modifiche rimanenti nella 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 Regex.Replace(String, String, MatchEvaluator) metodo utilizza un'espressione lambda per eseguire la sostituzione su 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. Si esegue questa conversione chiamando il StringBuilder.ToString (metodo).You perform this conversion by calling the StringBuilder.ToString method. Per informazioni generali, vedere l'esempio precedente, che chiama il ToString metodo per convertire un StringBuilder oggetto in una stringa in modo che possa essere passata 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 nel .NET Framework 4.0 e versioni successive, quando si crea un'istanza di StringBuilder chiamando il StringBuilder(Int32, Int32) costruttore, sia la lunghezza e la capacità del StringBuilder istanza può crescere oltre il valore di relativo MaxCapacity proprietà.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. Ciò può verificarsi in particolare quando si chiama il Append(String) e AppendFormat(String, Object) metodi 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() StringBuilder() StringBuilder() StringBuilder()

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

StringBuilder(Int32) StringBuilder(Int32) StringBuilder(Int32) 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) StringBuilder(Int32, Int32) StringBuilder(Int32, Int32) 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) StringBuilder(String) StringBuilder(String) 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) StringBuilder(String, Int32) StringBuilder(String, Int32) 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) StringBuilder(String, Int32, Int32, Int32) StringBuilder(String, Int32, Int32, Int32) 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 Capacity Capacity 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] Chars[Int32] Chars[Int32] 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 Length Length Length

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

MaxCapacity MaxCapacity MaxCapacity MaxCapacity

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

Metodi

Append(Boolean) Append(Boolean) Append(Boolean) 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) Append(Byte) Append(Byte) 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) Append(Char) Append(Char) 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) Append(Char*, Int32) Append(Char*, Int32) 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) Append(Char, Int32) Append(Char, Int32) 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[]) Append(Char[]) Append(Char[]) 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) Append(Char[], Int32, Int32) Append(Char[], Int32, Int32) 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) Append(Decimal) Append(Decimal) 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) Append(Double) Append(Double) 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) Append(Int16) Append(Int16) 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) Append(Int32) Append(Int32) 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) Append(Int64) Append(Int64) 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) Append(Object) Append(Object) 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>) Append(ReadOnlyMemory<Char>) Append(ReadOnlyMemory<Char>) Append(ReadOnlyMemory<Char>)
Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>)
Append(SByte) Append(SByte) Append(SByte) 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) Append(Single) Append(Single) 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) Append(String) Append(String) 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) Append(String, Int32, Int32) Append(String, Int32, Int32) 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) Append(StringBuilder) Append(StringBuilder) Append(StringBuilder)
Append(StringBuilder, Int32, Int32) Append(StringBuilder, Int32, Int32) Append(StringBuilder, Int32, Int32) Append(StringBuilder, Int32, Int32)
Append(UInt16) Append(UInt16) Append(UInt16) 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) Append(UInt32) Append(UInt32) 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) Append(UInt64) Append(UInt64) 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) AppendFormat(IFormatProvider, String, Object) AppendFormat(IFormatProvider, String, Object) 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) AppendFormat(IFormatProvider, String, Object, Object) AppendFormat(IFormatProvider, String, Object, Object) 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) AppendFormat(IFormatProvider, String, Object, Object, Object) AppendFormat(IFormatProvider, String, Object, Object, Object) 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[]) AppendFormat(IFormatProvider, String, Object[]) AppendFormat(IFormatProvider, String, Object[]) 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) AppendFormat(String, Object) AppendFormat(String, Object) 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) AppendFormat(String, Object, Object) AppendFormat(String, Object, Object) 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) AppendFormat(String, Object, Object, Object) AppendFormat(String, Object, Object, Object) 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[]) AppendFormat(String, Object[]) AppendFormat(String, Object[]) 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[]) AppendJoin(Char, Object[]) AppendJoin(Char, Object[]) AppendJoin(Char, Object[])
AppendJoin(Char, String[]) AppendJoin(Char, String[]) AppendJoin(Char, String[]) AppendJoin(Char, String[])
AppendJoin(String, Object[]) AppendJoin(String, Object[]) AppendJoin(String, Object[]) AppendJoin(String, Object[])
AppendJoin(String, String[]) AppendJoin(String, String[]) AppendJoin(String, String[]) AppendJoin(String, String[])
AppendJoin<T>(Char, IEnumerable<T>) AppendJoin<T>(Char, IEnumerable<T>) AppendJoin<T>(Char, IEnumerable<T>) AppendJoin<T>(Char, IEnumerable<T>)
AppendJoin<T>(String, IEnumerable<T>) AppendJoin<T>(String, IEnumerable<T>) AppendJoin<T>(String, IEnumerable<T>) AppendJoin<T>(String, IEnumerable<T>)
AppendLine() AppendLine() AppendLine() AppendLine()

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) AppendLine(String) AppendLine(String) 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() Clear() Clear() Clear()

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

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

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) CopyTo(Int32, Span<Char>, Int32) CopyTo(Int32, Span<Char>, Int32) CopyTo(Int32, Span<Char>, Int32)
EnsureCapacity(Int32) EnsureCapacity(Int32) EnsureCapacity(Int32) 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) Equals(Object) Equals(Object) Equals(Object)

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

(Inherited from Object)
Equals(ReadOnlySpan<Char>) Equals(ReadOnlySpan<Char>) Equals(ReadOnlySpan<Char>) Equals(ReadOnlySpan<Char>)

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) Equals(StringBuilder) Equals(StringBuilder) 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() GetChunks() GetChunks() GetChunks()
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

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

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

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

(Inherited from Object)
Insert(Int32, Boolean) Insert(Int32, Boolean) Insert(Int32, Boolean) 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) Insert(Int32, Byte) Insert(Int32, Byte) 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) Insert(Int32, Char) Insert(Int32, Char) 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[]) Insert(Int32, Char[]) Insert(Int32, Char[]) 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) Insert(Int32, Char[], Int32, Int32) Insert(Int32, Char[], Int32, Int32) 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) Insert(Int32, Decimal) Insert(Int32, Decimal) 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) Insert(Int32, Double) Insert(Int32, Double) 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) Insert(Int32, Int16) Insert(Int32, Int16) 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) Insert(Int32, Int32) Insert(Int32, Int32) 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) Insert(Int32, Int64) Insert(Int32, Int64) 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) Insert(Int32, Object) Insert(Int32, Object) 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>) Insert(Int32, ReadOnlySpan<Char>) Insert(Int32, ReadOnlySpan<Char>) Insert(Int32, ReadOnlySpan<Char>)
Insert(Int32, SByte) Insert(Int32, SByte) Insert(Int32, SByte) 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) Insert(Int32, Single) Insert(Int32, Single) 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) Insert(Int32, String) Insert(Int32, String) 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) Insert(Int32, String, Int32) Insert(Int32, String, Int32) 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) Insert(Int32, UInt16) Insert(Int32, UInt16) 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) Insert(Int32, UInt32) Insert(Int32, UInt32) 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) Insert(Int32, UInt64) Insert(Int32, UInt64) 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() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

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

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

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) 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) Replace(Char, Char, Int32, Int32) Replace(Char, Char, Int32, Int32) 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) Replace(String, String) Replace(String, String) 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) Replace(String, String, Int32, Int32) Replace(String, String, Int32, Int32) 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() ToString() ToString() ToString()

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

ToString(Int32, Int32) ToString(Int32, Int32) ToString(Int32, Int32) 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) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) 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