StringBuilder StringBuilder StringBuilder StringBuilder Class

Definition

Stellt eine veränderbare Zeichenfolge dar.Represents a mutable string of characters. Diese Klasse kann nicht vererbt werden.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
Vererbung
StringBuilderStringBuilderStringBuilderStringBuilder
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird gezeigt, wie viele der Methoden aufgerufen werden, die StringBuilder von der-Klasse definiert werden.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

Hinweise

Diese Klasse stellt ein Zeichen folgen ähnliches Objekt dar, dessen Wert eine änderbare Zeichenfolge ist.This class represents a string-like object whose value is a mutable sequence of characters.

In diesem AbschnittIn this section:

Die Zeichen folgen-und StringBuilder-TypenThe String and StringBuilder types

Obwohl StringBuilder undString beide Zeichen folgen darstellen, werden Sie anders implementiert.Although StringBuilder and String both represent sequences of characters, they are implemented differently. Stringist ein unveränderlicher Typ.String is an immutable type. Das heißt, dass jeder Vorgang, der zum Ändern String eines-Objekts erscheint, tatsächlich eine neue Zeichenfolge erstellt.That is, each operation that appears to modify a String object actually creates a new string.

Beispielsweise wird der String.Concat -Befehl der-Methode im folgenden C# Beispiel angezeigt, um den Wert einer Zeichen folgen Variablen mit valuedem Namen zu ändern.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. Tatsächlich gibt die Concat -Methode ein value -Objekt zurück, das über einen anderen Wert und eine value andere Adresse als das-Objekt verfügt, das an die-Methode übermittelt wurde.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. Beachten Sie, dass das Beispiel mit der /unsafe -Compileroption kompiliert werden muss.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

Bei Routinen, die eine umfangreiche Zeichen folgen Bearbeitung ausführen (z. b. apps, die eine Zeichenfolge mehrmals in einer Schleife ändern), kann das Ändern einer Zeichenfolge zu einer erheblichen Leistungs Einbuße führen.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. Die Alternative ist die Verwendung StringBuildervon, bei der es sich um eine änderbare Zeichen folgen Klasse handelt.The alternative is to use StringBuilder, which is a mutable string class. Muability bedeutet, dass nach dem Erstellen einer Instanz der Klasse diese geändert werden kann, indem Zeichen angehängt, entfernt, ersetzt oder eingefügt werden.Mutability means that once an instance of the class has been created, it can be modified by appending, removing, replacing, or inserting characters. Ein StringBuilder -Objekt verwaltet einen Puffer, um Erweiterungen für die Zeichenfolge zu ermöglichen.A StringBuilder object maintains a buffer to accommodate expansions to the string. Neue Daten werden an den Puffer angehängt, wenn Platz verfügbar ist. Andernfalls wird ein neuer, größerer Puffer zugewiesen, Daten aus dem ursprünglichen Puffer werden in den neuen Puffer kopiert, und die neuen Daten werden dann an den neuen Puffer angehängt.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.

Wichtig

Obwohl die StringBuilder -Klasse in der Regel eine bessere String Leistung als die-Klasse bietet, String StringBuilder sollten Sie nicht automatisch ersetzen, wenn Sie Zeichen folgen bearbeiten möchten.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. Die Leistung hängt von der Größe der Zeichenfolge, der Menge an Arbeitsspeicher, die für die neue Zeichenfolge zugewiesen werden soll, dem System, in dem Ihre APP ausgeführt wird, und dem Typ des Vorgangs ab.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. Sie sollten darauf vorbereitet sein, Ihre APP zu testen, StringBuilder um zu ermitteln, ob tatsächlich eine beträchtliche Leistungsverbesserung bietet.You should be prepared to test your app to determine whether StringBuilder actually offers a significant performance improvement.

Verwenden Sie die String -Klasse unter folgenden Bedingungen:Consider using the String class under these conditions:

  • Wenn die Anzahl der Änderungen, die Ihre APP an einer Zeichenfolge vornehmen wird, gering ist.When the number of changes that your app will make to a string is small. In diesen Fällen StringBuilder bietet möglicherweise eine vernachlässigbare oder keine StringLeistungsverbesserung gegenüber.In these cases, StringBuilder might offer negligible or no performance improvement over String.

  • Bei der Durchführung einer bestimmten Anzahl von Verkettungs Vorgängen, insbesondere bei Zeichenfolgenliteralen.When you are performing a fixed number of concatenation operations, particularly with string literals. In diesem Fall kann der Compiler die Verkettungs Vorgänge in einem einzelnen Vorgang kombinieren.In this case, the compiler might combine the concatenation operations into a single operation.

  • Wenn Sie umfangreiche Suchvorgänge ausführen müssen, während Sie die Zeichenfolge aufbauen.When you have to perform extensive search operations while you are building your string. Die StringBuilder Klasse hat keine Suchmethoden IndexOf wie oder StartsWith.The StringBuilder class lacks search methods such as IndexOf or StartsWith. Sie müssen das StringBuilder -Objekt für diese Vorgänge in String einen konvertieren, und dies kann die Leistungsvorteile von der Verwendung StringBuildervon negieren.You'll have to convert the StringBuilder object to a String for these operations, and this can negate the performance benefit from using StringBuilder. Weitere Informationen finden Sie im Abschnitt Suchen des Texts in einem StringBuilder-Objekt .For more information, see the Searching the text in a StringBuilder object section.

Verwenden Sie die StringBuilder -Klasse unter folgenden Bedingungen:Consider using the StringBuilder class under these conditions:

  • Wenn Sie davon ausgehen, dass Ihre APP zur Entwurfszeit eine unbekannte Anzahl von Änderungen an einer Zeichenfolge vornimmt (z. b. Wenn Sie eine Schleife verwenden, um eine zufällige Anzahl von Zeichen folgen zu verketten, die Benutzereingaben enthalten).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).

  • Wenn Sie davon ausgehen, dass Ihre APP eine beträchtliche Anzahl von Änderungen an einer Zeichenfolge vornehmen soll.When you expect your app to make a significant number of changes to a string.

Funktionsweise von StringBuilderHow StringBuilder works

Die StringBuilder.Length -Eigenschaft gibt die Anzahl der Zeichen StringBuilder an, die das-Objekt zurzeit enthält.The StringBuilder.Length property indicates the number of characters the StringBuilder object currently contains. Wenn Sie dem StringBuilder -Objekt Zeichen hinzufügen, vergrößert sich seine Länge, bis die Größe StringBuilder.Capacity der-Eigenschaft entspricht, die die Anzahl der Zeichen definiert, die das Objekt enthalten kann.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. Wenn die Anzahl der hinzugefügten Zeichen bewirkt, dass StringBuilder die Länge des Objekts die aktuelle Kapazität überschreitet, wird neuer Speicher zugeordnet, der Capacity Wert der Eigenschaft wird verdoppelt, neue Zeichen werden dem StringBuilder Objekt hinzugefügt, und Lengthderzugehörigedie Eigenschaft wird angepasst.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. Zusätzlicher Arbeitsspeicher für StringBuilder das Objekt wird dynamisch zugewiesen, bis der von der StringBuilder.MaxCapacity -Eigenschaft definierte Wert erreicht wird.Additional memory for the StringBuilder object is allocated dynamically until it reaches the value defined by the StringBuilder.MaxCapacity property. Wenn die maximale Kapazität erreicht ist, kann dem StringBuilder Objekt kein weiterer Arbeitsspeicher zugeordnet werden. Wenn Sie versuchen, Zeichen hinzuzufügen oder Sie außerhalb der maximalen Kapazität zu erweitern, wird entweder eine ArgumentOutOfRangeException -Ausnahme oder eine OutOfMemoryException -Ausnahme ausgelöst.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.

Im folgenden Beispiel wird veranschaulicht, StringBuilder wie ein-Objekt neuen Arbeitsspeicher zuordnet und seine Kapazität dynamisch vergrößert, wenn die dem-Objekt zugewiesene Zeichenfolge erweitert wird.The following example illustrates how a StringBuilder object allocates new memory and increases its capacity dynamically as the string assigned to the object expands. Der Code erstellt ein StringBuilder -Objekt durch Aufrufen seines Standard Konstruktors (parameterlos).The code creates a StringBuilder object by calling its default (parameterless) constructor. Die Standardkapazität dieses Objekts beträgt 16 Zeichen, und die maximale Kapazität beträgt mehr als 2 Milliarden Zeichen.The default capacity of this object is 16 characters, and its maximum capacity is more than 2 billion characters. Die Zeichenfolge "This is a Satz" wird angehängt.Appending the string "This is a sentence." führt zu einer neuen Speicher Belegung, da die Zeichen folgen Länge (19 Zeichen) die Standardkapazität des StringBuilder -Objekts überschreitet.results in a new memory allocation because the string length (19 characters) exceeds the default capacity of the StringBuilder object. Die Kapazität des-Objekts wird auf 32 Zeichen verdoppelt, die neue Zeichenfolge wird hinzugefügt, und die Länge des-Objekts entspricht nun 19 Zeichen.The capacity of the object doubles to 32 characters, the new string is added, and the length of the object now equals 19 characters. Der Code fügt dann die Zeichenfolge "This is a additional Satz" an.The code then appends the string "This is an additional sentence." zum Wert des StringBuilder -Objekts 11 Mal.to the value of the StringBuilder object 11 times. Wenn der Anfüge Vorgang bewirkt, dass die Länge StringBuilder des Objekts seine Kapazität überschreitet, wird die vorhandene Kapazität verdoppelt, Append und der Vorgang wird erfolgreich ausgeführt.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

ArbeitsspeicherbelegungMemory allocation

Die Standardkapazität StringBuilder eines-Objekts beträgt 16 Zeichen, und die maximale Standardkapazität ist Int32.MaxValue.The default capacity of a StringBuilder object is 16 characters, and its default maximum capacity is Int32.MaxValue. Diese Standardwerte werden verwendet, wenn Sie die StringBuilder() Konstruktoren und StringBuilder(String) aufzurufen.These default values are used if you call the StringBuilder() and StringBuilder(String) constructors.

Sie können die anfängliche Kapazität StringBuilder eines-Objekts auf folgende Weise explizit definieren:You can explicitly define the initial capacity of a StringBuilder object in the following ways:

  • Durch Aufrufen StringBuilder eines Konstruktors, der einen capacity -Parameter enthält, wenn Sie das-Objekt erstellen.By calling any of the StringBuilder constructors that includes a capacity parameter when you create the object.

  • Durch explizites Zuweisen eines neuen Werts StringBuilder.Capacity zur-Eigenschaft, um StringBuilder ein vorhandenes Objekt zu erweitern.By explicitly assigning a new value to the StringBuilder.Capacity property to expand an existing StringBuilder object. Beachten Sie, dass die-Eigenschaft eine Ausnahme auslöst, wenn die neue Kapazität kleiner als die vorhandene Kapazität oder StringBuilder größer als die maximale Kapazität des Objekts ist.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.

  • Durch Aufrufen der StringBuilder.EnsureCapacity -Methode mit der neuen Kapazität.By calling the StringBuilder.EnsureCapacity method with the new capacity. Die neue Kapazität darf nicht größer sein als die StringBuilder maximale Kapazität des Objekts.The new capacity must not be greater than the StringBuilder object's maximum capacity. Anders als bei einer Zuweisung zur Capacity -Eigenschaft löst jedoch keine Ausnahme aus, EnsureCapacity wenn die gewünschte neue Kapazität kleiner ist als die vorhandene Kapazität. in diesem Fall hat der Methodenaufrufe keine Auswirkung.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.

Wenn die Länge der Zeichenfolge, die dem StringBuilder -Objekt im konstruktorbefehl zugewiesen ist, entweder die Standardkapazität oder die angegebene Kapazität Capacity überschreitet, wird die-Eigenschaft auf die Länge der Zeichen value Folge festgelegt, die mit dem-Parameter angegeben wird.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.

Sie können die maximale Kapazität eines StringBuilder -Objekts explizit definieren, indem Sie den StringBuilder(Int32, Int32) -Konstruktor aufrufen.You can explicitly define the maximum capacity of a StringBuilder object by calling the StringBuilder(Int32, Int32) constructor. Sie können die maximale Kapazität nicht ändern, indem Sie der MaxCapacity Eigenschaft einen neuen Wert zuweisen, da sie schreibgeschützt ist.You can't change the maximum capacity by assigning a new value to the MaxCapacity property, because it is read-only.

Wie im vorherigen Abschnitt gezeigt, wird, wenn die vorhandene Kapazität unzureichend ist, zusätzlicher Arbeitsspeicher zugeordnet, und die StringBuilder Kapazität eines-Objekts verdoppelt sich auf den Wert MaxCapacity , der durch die-Eigenschaft definiert wird.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.

Im Allgemeinen sind die Standardkapazität und die maximale Kapazität für die meisten apps ausreichend.In general, the default capacity and maximum capacity are adequate for most apps. Sie sollten diese Werte unter folgenden Bedingungen festlegen:You might consider setting these values under the following conditions:

  • , Wenn die endgültige Größe des StringBuilder Objekts wahrscheinlich übermäßig groß wird, in der Regel über mehrere Megabyte hinaus.If the eventual size of the StringBuilder object is likely to grow exceedingly large, typically in excess of several megabytes. In diesem Fall kann es zu Leistungsvorteilen kommen, wenn die anfängliche Capacity Eigenschaft auf einen erheblich hohen Wert festgelegt wird, um zu viele Speicher Belegungen zu vermeiden.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.

  • Wenn Ihre APP auf einem System mit eingeschränktem Arbeitsspeicher ausgeführt wird.If your app is running on a system with limited memory. In diesem Fall empfiehlt es sich, die MaxCapacity -Eigenschaft auf weniger als Int32.MaxValue festzulegen, wenn Ihre APP große Zeichen folgen verarbeitet, die die Ausführung in einer Speicher eingeschränkten Umgebung bewirken können.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.

Instanziieren eines StringBuilder-ObjektsInstantiating a StringBuilder object

Instanziieren Sie ein StringBuilder -Objekt, indem Sie einen der sechs überladenen Klassenkonstruktoren aufrufen, die in der folgenden Tabelle aufgeführt sind.You instantiate a StringBuilder object by calling one of its six overloaded class constructors, which are listed in the following table. Drei der Konstruktoren instanziieren ein StringBuilder -Objekt, dessen Wert eine leere Zeichenfolge ist, wobei die MaxCapacity Capacity Werte und jedoch unterschiedlich festgelegt werden.Three of the constructors instantiate a StringBuilder object whose value is an empty string, but set its Capacity and MaxCapacity values differently. Die verbleibenden drei Konstruktoren definieren StringBuilder ein-Objekt, das einen bestimmten Zeichen folgen Wert und eine bestimmte Kapazität aufweist.The remaining three constructors define a StringBuilder object that has a specific string value and capacity. Zwei der drei Konstruktoren verwenden die maximale Standardkapazität von Int32.MaxValue, während mit dem dritten die maximale Kapazität festgelegt werden kann.Two of the three constructors use the default maximum capacity of Int32.MaxValue, whereas the third allows you to set the maximum capacity.

KonstruktorConstructor Zeichen folgen WertString value KapazitätCapacity Maximale KapazitätMaximum capacity
StringBuilder() String.Empty 1616 Int32.MaxValue
StringBuilder(Int32) String.Empty Definiert durch den capacity -ParameterDefined by the capacity parameter Int32.MaxValue
StringBuilder(Int32, Int32) String.Empty Definiert durch den capacity -ParameterDefined by the capacity parameter Definiert durch den maxCapacity -ParameterDefined by the maxCapacity parameter
StringBuilder(String) Definiert durch den value -ParameterDefined by the value parameter 16 oder value.16 or value. Length, je nachdem, welche größer istLength, whichever is greater Int32.MaxValue
StringBuilder(String, Int32) Definiert durch den value -ParameterDefined by the value parameter Definiert durch den capacity -Parameter valueoder.Defined by the capacity parameter or value. Length, je nachdem, welche größer ist.Length, whichever is greater. Int32.MaxValue
StringBuilder(String, Int32, Int32, Int32) wird von value definiertDefined by value. Substring(startIndex, length)Substring(startIndex, length) Definiert durch den capacity -Parameter valueoder.Defined by the capacity parameter or value. Length, je nachdem, welche größer ist.Length, whichever is greater. Definiert durch den maxCapacity -ParameterDefined by the maxCapacity parameter

Im folgenden Beispiel werden drei dieser Konstruktorüberladungen verwendet, um-Objekte StringBuilder zu instanziieren.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

Aufrufen von StringBuilder-MethodenCalling StringBuilder methods

Die meisten der Methoden, die die Zeichenfolge in StringBuilder einer-Instanz ändern, geben einen Verweis auf dieselbe Instanz zurück.Most of the methods that modify the string in a StringBuilder instance return a reference to that same instance. Dies ermöglicht es Ihnen, StringBuilder Methoden auf zwei Arten aufzurufen:This enables you to call StringBuilder methods in two ways:

  • Sie können einzelne Methodenaufrufe durchführen und den Rückgabewert ignorieren, wie im folgenden Beispiel gezeigt.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.
    
  • Sie können eine Reihe von Methoden aufrufen in einer einzelnen Anweisung ausführen.You can make a series of method calls in a single statement. Dies kann praktisch sein, wenn Sie eine einzelne Anweisung schreiben möchten, die aufeinander folgende Vorgänge verkettet.This can be convenient if you want to write a single statement that chains successive operations. Im folgenden Beispiel werden drei Methodenaufrufe aus dem vorherigen Beispiel in eine einzelne Codezeile konsolidiert.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.
    

Ausführen von StringBuilder-VorgängenPerforming StringBuilder operations

Sie können die Methoden der StringBuilder -Klasse verwenden, um Zeichen in einem StringBuilder -Objekt zu durchlaufen, hinzuzufügen, zu löschen oder zu ändern.You can use the methods of the StringBuilder class to iterate, add, delete, or modify characters in a StringBuilder object.

Iterieren von StringBuilder-ZeichenIterating StringBuilder characters

Sie können auf die Zeichen in einem StringBuilder -Objekt zugreifen, StringBuilder.Chars[Int32] indem Sie die-Eigenschaft verwenden.You can access the characters in a StringBuilder object by using the StringBuilder.Chars[Int32] property. In C#ist ein Indexer, in Visual Basic die StringBuilder Standard Eigenschaft der-Klasse. Chars[Int32]In C#, Chars[Int32] is an indexer; in Visual Basic, it is the default property of the StringBuilder class. Dies ermöglicht es Ihnen, einzelne Zeichen nur mit Ihrem Index festzulegen oder abzurufen, ohne explizit auf die Chars[Int32] Eigenschaft zu verweisen.This enables you to set or retrieve individual characters by using their index only, without explicitly referencing the Chars[Int32] property. Zeichen in einem StringBuilder -Objekt beginnen am Index 0 (null) und fahren mit Length dem Index-1 fort.Characters in a StringBuilder object begin at index 0 (zero) and continue to index Length - 1.

Im folgenden Beispiel wird die Chars[Int32] -Eigenschaft veranschaulicht.The following example illustrates the Chars[Int32] property. Es fügt zehn Zufallszahlen an ein StringBuilder -Objekt an und iteriert dann jedes Zeichen.It appends ten random numbers to a StringBuilder object, and then iterates each character. Wenn die Unicode-Kategorie des Zeichens UnicodeCategory.DecimalDigitNumberist, wird die Zahl um 1 verringert (oder die Zahl wird auf 9 geändert, wenn der Wert 0 ist).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). Im Beispiel wird der Inhalt des StringBuilder -Objekts sowohl vor als auch nach dem Ändern der Werte einzelner Zeichen angezeigt.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

Das Verwenden von zeichenbasierter Indizierung mit der Chars[Int32]-Eigenschaft kann unter folgenden Bedingungen sehr langsam sein:Using character-based indexing with the Chars[Int32] property can be extremely slow under the following conditions:

  • Die StringBuilder-Instanz ist groß, weil sie beispielsweise aus Zehntausenden von Zeichen besteht.The StringBuilder instance is large (for example, it consists of several tens of thousands of characters).
  • StringBuilder ist „blockweise“ strukturiert.The StringBuilder is "chunky." Das bedeutet, dass wiederholte Aufrufe von Methoden (z.B. StringBuilder.Append) die StringBuilder.Capacity-Eigenschaft des Objekts automatisch erweitert haben und dieser neue Arbeitsspeicherblöcke zugeordnet haben.That is, repeated calls to methods such as StringBuilder.Append have automatically expanded the object's StringBuilder.Capacity property and allocated new chunks of memory to it.

Die Leistung wird erheblich beeinträchtigt, da für jeden Zugriff auf ein Zeichen die gesamte verknüpfte Liste der Blöcke durchlaufen wird, um den richtigen Puffer für die Indizierung zu suchen.Performance is severely impacted because each character access walks the entire linked list of chunks to find the correct buffer to index into.

Hinweis

Auch für ein „blockweise“ strukturiertes StringBuilder-Objekt kann das Verwenden der Chars[Int32]-Eigenschaft für den indexbasierten Zugriff auf ein oder wenige Zeichen eine negative Auswirkung auf die Leistung haben. Üblicherweise handelt es sich dabei um eine 0(n) -Operation.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. Diese erheblichen Auswirkungen auf die Leistung treten auf, wenn die Zeichen im StringBuilder-Objekt durchlaufen werden. Dabei handelt es sich um eine O(n^2) -Operation.The significant performance impact occurs when iterating the characters in the StringBuilder object, which is an O(n^2) operation.

Wenn Leistungsprobleme auftreten, wenn Sie die zeichenbasierte Indizierung mit StringBuilder-Objekten verwenden, können Sie eine der folgenden Problemumgehungen anwenden:If you encounter performance issues when using character-based indexing with StringBuilder objects, you can use any of the following workarounds:

  • Konvertieren Sie die StringBuilder-Instanz zu String, indem Sie die ToString-Methode aufrufen. Greifen Sie dann auf die Zeichen in der Zeichenfolge zu.Convert the StringBuilder instance to a String by calling the ToString method, then access the characters in the string.

  • Kopieren Sie die Inhalte des vorhandenen StringBuilder-Objekts in ein neues StringBuilder-Objekt mit vorab festgelegter Größe.Copy the contents of the existing StringBuilder object to a new pre-sized StringBuilder object. Die Leistung verbessert sich, da das neue StringBuilder-Objekt nicht „blockweise“ strukturiert ist.Performance improves because the new StringBuilder object is not chunky. Beispiel: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)
    
  • Legen Sie die anfängliche Kapazität des StringBuilder-Objekts auf einen Wert fest, der ungefähr der maximal erwarteten Größe entspricht, indem der StringBuilder(Int32)-Konstruktor aufgerufen wird.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. Beachten Sie, dass dadurch der gesamte Arbeitsspeicherblock zugeordnet wird, auch wenn StringBuilder selten die maximale Kapazität erreicht.Note that this allocates the entire block of memory even if the StringBuilder rarely reaches its maximum capacity.

Hinzufügen von Text zu einem StringBuilder-ObjektAdding text to a StringBuilder object

Die StringBuilder -Klasse enthält die folgenden Methoden zum Erweitern des Inhalts StringBuilder eines-Objekts:The StringBuilder class includes the following methods for expanding the contents of a StringBuilder object:

  • Die Append -Methode fügt eine Zeichenfolge, eine Teil Zeichenfolge, ein Zeichen Array, einen Teil eines Zeichen Arrays, ein einzelnes Zeichen, das mehrmals wiederholt wird, oder die Zeichen folgen Darstellung eines StringBuilder primitiven Datentyps an ein-Objekt an.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.

  • Die AppendLine -Methode fügt ein Zeilen Abschluss Zeichen oder eine Zeichenfolge zusammen mit einem Zeichen für StringBuilder den Zeilen Abschluss an ein-Objekt an.The AppendLine method appends a line terminator or a string along with a line terminator to a StringBuilder object.

  • Die AppendFormat -Methode fügt eine kombinierte Format Zeichenfolge an ein StringBuilder -Objekt an.The AppendFormat method appends a composite format string to a StringBuilder object. Die Zeichen folgen Darstellungen von Objekten, die in der Ergebnis Zeichenfolge enthalten sind, können die Formatierungs Konventionen der aktuellen System Kultur oder der angegebenen Kultur widerspiegeln.The string representations of objects included in the result string can reflect the formatting conventions of the current system culture or a specified culture.

  • Die Insert -Methode fügt eine Zeichenfolge, eine Teil Zeichenfolge, mehrere Wiederholungen einer Zeichenfolge, ein Zeichen Array, einen Teil eines Zeichen Arrays oder die Zeichen folgen Darstellung eines primitiven Datentyps an einer StringBuilder angegebenen Position im-Objekt ein.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. Die Position wird durch einen NULL basierten Index definiert.The position is defined by a zero-based index.

Im folgenden Beispiel werden die AppendMethoden AppendLine, AppendFormat Insert ,StringBuilder und verwendet, um den Text eines-Objekts zu erweitern.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            <

Löschen von Text aus einem StringBuilder-ObjektDeleting text from a StringBuilder object

Die StringBuilder -Klasse enthält Methoden, mit denen die Größe der aktuellen StringBuilder Instanz reduziert werden kann.The StringBuilder class includes methods that can reduce the size of the current StringBuilder instance. Die Clear -Methode entfernt alle Zeichen und legt Length die-Eigenschaft auf 0 (null) fest.The Clear method removes all characters and sets the Length property to zero. Die Remove -Methode löscht eine angegebene Anzahl von Zeichen ab einer bestimmten Indexposition.The Remove method deletes a specified number of characters starting at a particular index position. Außerdem können Sie Zeichen vom Ende eines StringBuilder -Objekts entfernen, indem Sie die Length -Eigenschaft auf einen Wert festlegen, der kleiner als die Länge der aktuellen Instanz ist.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.

Im folgenden Beispiel wird ein Teil des Texts aus einem StringBuilder -Objekt entfernt, dessen resultierende Kapazitäts-, maximale Kapazitäts-und Längen Eigenschaftswerte angezeigt, Clear und anschließend wird die-Methode aufgerufen, StringBuilder um alle Zeichen aus dem-Objekt zu entfernen.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

Ändern des Texts in einem StringBuilder-ObjektModifying the text in a StringBuilder object

Die StringBuilder.Replace -Methode ersetzt alle Vorkommen eines Zeichens oder einer Zeichenfolge im gesamten StringBuilder Objekt oder in einem bestimmten Zeichenbereich.The StringBuilder.Replace method replaces all occurrences of a character or a string in the entire StringBuilder object or in a particular character range. Im folgenden Beispiel wird die Replace -Methode verwendet, um alle Ausrufezeichen (!) durch Fragezeichen (?) StringBuilder im-Objekt zu ersetzen.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?

Durchsuchen des Texts in einem StringBuilder-ObjektSearching the text in a StringBuilder object

Die StringBuilder -Klasse enthält keine ähnlichen Methoden wie die String.ContainsMethoden String.IndexOf, und String.StartsWith , die von der String -Klasse bereitgestellt werden, mit denen Sie das-Objekt nach einem bestimmten Zeichen oder einer Teil Zeichenfolge durchsuchen können.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. Wenn Sie die Anwesenheits Position oder die Anfangs Zeichenposition einer Teil Zeichenfolge ermitteln String , müssen Sie einen Wert entweder mithilfe einer Zeichen folgen Suchmethode oder einer Methode für reguläre Ausdrücke durchsuchen.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. Es gibt vier Möglichkeiten, solche Suchvorgänge zu implementieren, wie in der folgenden Tabelle gezeigt.There are four ways to implement such searches, as the following table shows.

FahrTechnique VorteilePros NachteileCons
Suchzeichen folgen Werte, bevor Sie dem StringBuilder -Objekt hinzugefügt werden.Search string values before adding them to the StringBuilder object. Nützlich für die Bestimmung, ob eine Teil Zeichenfolge vorhanden ist.Useful for determining whether a substring exists. Kann nicht verwendet werden, wenn die Indexposition einer Teil Zeichenfolge wichtig ist.Cannot be used when the index position of a substring is important.
Ruft ToString auf und durchsucht String das zurückgegebene-Objekt.Call ToString and search the returned String object. Einfach zu verwenden, wenn Sie den gesamten Text einem StringBuilder -Objekt zuweisen und dann beginnen, ihn zu ändern.Easy to use if you assign all the text to a StringBuilder object, and then begin to modify it. Es ist mühsam, ToString wiederholt aufzurufen, wenn Sie Änderungen vornehmen müssen, bevor StringBuilder dem Objekt der gesamte Text hinzugefügt wird.Cumbersome to repeatedly call ToString if you must make modifications before all text is added to the StringBuilder object.

Wenn Sie Änderungen vornehmen, müssen Sie daran denken, StringBuilder am Ende des Objekt Texts zu arbeiten.You must remember to work from the end of the StringBuilder object's text if you're making changes.
Verwenden Sie Chars[Int32] die-Eigenschaft, um einen Bereich von Zeichen sequenziell zu durchsuchen.Use the Chars[Int32] property to sequentially search a range of characters. Nützlich, wenn Sie sich mit einzelnen Zeichen oder einer kleinen Teil Zeichenfolge beschäftigen.Useful if you're concerned with individual characters or a small substring. Umständlich, wenn die Anzahl der zu suchenden Zeichen groß ist oder die Suchlogik Komplex ist.Cumbersome if the number of characters to search is large or if the search logic is complex.

Führt zu einer sehr schlechten Leistung für Objekte, die durch wiederholte Methodenaufrufe sehr groß geworden sind.Results in very poor performance for objects that have grown very large through repeated method calls.
Konvertieren Sie StringBuilder das -ObjektString in ein-Objekt, und führen Sie Änderungen am- Objektaus.StringConvert the StringBuilder object to a String object, and perform modifications on the String object. Nützlich, wenn die Anzahl der Änderungen gering ist.Useful if the number of modifications is small. Negiert den Leistungsvorteil StringBuilder der-Klasse, wenn die Anzahl der Änderungen groß ist.Negates the performance benefit of the StringBuilder class if the number of modifications is large.

Betrachten wir diese Verfahren ausführlicher.Let's examine these techniques in greater detail.

  • Wenn das Ziel der Suche ist, zu bestimmen, ob eine bestimmte Teil Zeichenfolge vorhanden ist (d. h., wenn Sie nicht an der Position der Teil Zeichenfolge interessiert sind), können StringBuilder Sie Zeichen folgen vor dem Speichern im Objekt durchsuchen.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. Im folgenden Beispiel wird eine mögliche Implementierung bereitstellt.The following example provides one possible implementation. Es definiert eine StringBuilderFinder Klasse, deren Konstruktor einen Verweis auf ein StringBuilder -Objekt und die Teil Zeichenfolge, die in der Zeichenfolge gesucht werden soll, übergeben wird.It defines a StringBuilderFinder class whose constructor is passed a reference to a StringBuilder object and the substring to find in the string. In diesem Fall versucht das Beispiel zu ermitteln, ob sich die aufgezeichneten Temperaturen in Fahrenheit oder Celsius befinden, und fügt den entsprechenden einführenden Text am StringBuilder Anfang des Objekts hinzu.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. Ein Zufallszahlengenerator wird zum Auswählen eines Arrays verwendet, das Daten in Grad Celsius oder Grad Fahrenheit enthält.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
    
  • Ruft die StringBuilder.ToString -Methode auf, StringBuilder um das Objekt String in ein-Objekt zu konvertieren.Call the StringBuilder.ToString method to convert the StringBuilder object to a String object. Sie können die Zeichenfolge mithilfe von Methoden wie String.LastIndexOf oder String.StartsWithdurchsuchen, oder Sie können reguläre Ausdrücke und die Regex -Klasse verwenden, um nach Mustern zu suchen.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. Da sowohl StringBuilder - String als auch-Objekte UTF-16-Codierung zum Speichern von Zeichen verwenden, sind die Index Positionen von Zeichen, Teil Zeichenfolgen und Übereinstimmungen mit regulären Ausdrücken in beiden Objekten identisch.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. Dies ermöglicht es Ihnen, StringBuilder -Methoden zu verwenden, um Änderungen an derselben Position vorzunehmen, an der sich dieser String Text im-Objekt befindet.This enables you to use StringBuilder methods to make changes at the same position at which that text is found in the String object.

    Hinweis

    Wenn Sie diesen Ansatz anwenden, sollten Sie vom Ende des StringBuilder Objekts bis zum Anfang arbeiten, damit Sie das StringBuilder Objekt nicht wiederholt in eine Zeichenfolge konvertieren müssen.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.

    Dieser Ansatz wird anhand des folgenden Beispiels veranschaulicht.The following example illustrates this approach. Es speichert vier Vorkommen der einzelnen Buchstaben des englischen Alphabets in StringBuilder einem-Objekt.It stores four occurrences of each letter of the English alphabet in a StringBuilder object. Anschließend wird der Text in ein String -Objekt konvertiert, und es wird ein regulärer Ausdruck verwendet, um die Anfangsposition jeder vierstelligen Reihenfolge zu identifizieren.It then converts the text to a String object and uses a regular expression to identify the starting position of each four-character sequence. Schließlich wird vor jeder vierstelligen Sequenz mit Ausnahme der ersten Sequenz ein Unterstrich hinzugefügt, und das erste Zeichen der Sequenz wird in Großbuchstaben konvertiert.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
    
  • Verwenden Sie StringBuilder.Chars[Int32] die-Eigenschaft, um einen Bereich von Zeichen sequenziell StringBuilder in einem-Objekt zu durchsuchen.Use the StringBuilder.Chars[Int32] property to sequentially search a range of characters in a StringBuilder object. Diese Vorgehensweise ist möglicherweise nicht praktikabel, wenn die Anzahl der zu durchsuchenden Zeichen groß ist oder die Suchlogik besonders komplex ist.This approach may not be practical if the number of characters to be searched is large or the search logic is particularly complex. Die Auswirkungen auf die Leistung bei sehr großen, StringBuilder segmentierten Objekten, die sich auf den Index basieren, finden Sie in der Dokumentation für die StringBuilder.Chars[Int32] -Eigenschaft.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.

    Das folgende Beispiel ist identisch mit dem vorherigen Beispiel, aber unterscheidet sich von der Implementierung.The following example is identical in functionality to the previous example but differs in implementation. Er verwendet die Chars[Int32] -Eigenschaft, um zu erkennen, wann ein Zeichen Wert geändert wurde, fügt an dieser Position einen Unterstrich ein und konvertiert das erste Zeichen in der neuen Sequenz in Großbuchstaben.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
    
  • Speichert den gesamten StringBuilder unveränderten Text im-Objekt, ruft die StringBuilder.ToString -Methode auf, um das StringBuilder Objekt String in ein-Objekt zu konvertieren, und String führt die Änderungen am-Objekt aus.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. Sie können diesen Ansatz verwenden, wenn Sie nur wenige Änderungen haben. Andernfalls können die Kosten für die Arbeit mit unveränderlichen Zeichen folgen die Leistungsvorteile der Verwendung eines StringBuilder -Objekts negieren.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.

    Das folgende Beispiel ist identisch mit den beiden vorherigen Beispielen, unterscheidet sich jedoch von der Implementierung.The following example is identical in functionality to the previous two examples but differs in implementation. Er erstellt ein StringBuilder -Objekt, konvertiert es in String ein-Objekt und verwendet dann einen regulären Ausdruck, um alle verbleibenden Änderungen an der Zeichenfolge auszuführen.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. Die Regex.Replace(String, String, MatchEvaluator) -Methode verwendet einen Lambda-Ausdruck, um die Ersetzung bei den einzelnen vergleichen auszuführen.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
    

Umstellen des StringBuilder-Objekts in eine ZeichenfolgeConverting the StringBuilder object to a string

Sie müssen das StringBuilder-Objekt in ein String-Objekt konvertieren, bevor Sie die vom StringBuilder-Objekt dargestellte Zeichenfolge an eine Methode mit einem String-Parameter übergeben können oder diese auf der Benutzeroberfläche anzeigen.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. Diese Konvertierung führen Sie aus, indem StringBuilder.ToString Sie die-Methode aufrufen.You perform this conversion by calling the StringBuilder.ToString method. Eine Abbildung finden Sie im vorherigen Beispiel, das die ToString -Methode aufruft, um ein StringBuilder -Objekt in eine Zeichenfolge zu konvertieren, sodass es an eine Methode für reguläre Ausdrücke übermittelt werden kann.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.

Hinweise für Aufrufer

Wenn Sie in .net Core und in den .NET Framework 4,0 und höheren Versionen StringBuilder das Objekt durch Aufrufen des StringBuilder(Int32, Int32) Konstruktors instanziieren, können sowohl die Länge StringBuilder als auch die Kapazität der MaxCapacity Instanz über den Wert des Property.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. Dies kann besonders dann der Fall sein, Append(String) Wenn AppendFormat(String, Object) Sie die Methoden und zum Anfügen kleiner Zeichen folgen aufzurufen.This can occur particularly when you call the Append(String) and AppendFormat(String, Object) methods to append small strings.

Konstruktoren

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

Initialisiert eine neue Instanz der StringBuilder-Klasse.Initializes a new instance of the StringBuilder class.

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

Initialisiert eine neue Instanz der StringBuilder-Klasse unter Verwendung der angegebenen Kapazität.Initializes a new instance of the StringBuilder class using the specified capacity.

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

Initialisiert eine neue Instanz der StringBuilder-Klasse, die bei einer angegebenen Kapazität beginnt, die bis auf ein angegebenes Maximum erhöht werden kann.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)

Initialisiert eine neue Instanz der StringBuilder-Klasse unter Verwendung der angegebenen Zeichenfolge.Initializes a new instance of the StringBuilder class using the specified string.

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

Initialisiert eine neue Instanz der StringBuilder-Klasse unter Verwendung der angegebenen Zeichenfolge und der angegebenen Kapazität.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)

Initialisiert eine neue Instanz der StringBuilder-Klasse unter Verwendung der angegebenen Teilzeichenfolge und der angegebenen Kapazität.Initializes a new instance of the StringBuilder class from the specified substring and capacity.

Eigenschaften

Capacity Capacity Capacity Capacity

Ruft die Höchstanzahl von Zeichen ab, die im durch die aktuelle Instanz reservierten Speicher enthalten sein können, oder legt diese fest.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]

Ruft das Zeichen an der angegebenen Zeichenposition in dieser Instanz ab oder legt dieses fest.Gets or sets the character at the specified character position in this instance.

Length Length Length Length

Ruft die Länge des aktuellen StringBuilder-Objekts ab oder legt diese fest.Gets or sets the length of the current StringBuilder object.

MaxCapacity MaxCapacity MaxCapacity MaxCapacity

Ruft die maximale Kapazität dieser Instanz ab.Gets the maximum capacity of this instance.

Methoden

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

Fügt die Zeichenfolgendarstellung eines angegebenen booleschen Werts an diese Instanz an.Appends the string representation of a specified Boolean value to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen 8-Bit-Ganzzahl ohne Vorzeichen an diese Instanz an.Appends the string representation of a specified 8-bit unsigned integer to this instance.

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

Fügt die Zeichenfolgendarstellung eines angegebenen Char-Objekts an diese Instanz an.Appends the string representation of a specified Char object to this instance.

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

Fügt ein Array aus Unicode-Zeichen ab einer angegebenen Adresse an diese Instanz an.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)

Fügt eine angegebene Anzahl von Kopien der Zeichenfolgendarstellung eines Unicode-Zeichens an diese Instanz an.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[])

Fügt die Zeichenfolgendarstellung der Unicode-Zeichen in einem angegebenen Array an diese Instanz an.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)

Fügt die Zeichenfolgendarstellung eines angegebenen Unterarrays von Unicode-Zeichen an diese Instanz an.Appends the string representation of a specified subarray of Unicode characters to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen Dezimalzahl an diese Instanz an.Appends the string representation of a specified decimal number to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen Gleitkommazahl mit doppelter Genauigkeit an diese Instanz an.Appends the string representation of a specified double-precision floating-point number to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen 16-Bit-Ganzzahl mit Vorzeichen an diese Instanz an.Appends the string representation of a specified 16-bit signed integer to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen 32-Bit-Ganzzahl mit Vorzeichen an diese Instanz an.Appends the string representation of a specified 32-bit signed integer to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen 64-Bit-Ganzzahl mit Vorzeichen an diese Instanz an.Appends the string representation of a specified 64-bit signed integer to this instance.

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

Fügt die Zeichenfolgendarstellung eines angegebenen Objekts an diese Instanz an.Appends the string representation of a specified object to this instance.

Append(ReadOnlyMemory<Char>) Append(ReadOnlyMemory<Char>) Append(ReadOnlyMemory<Char>) Append(ReadOnlyMemory<Char>)

Fügt die Zeichenfolgendarstellung eines festgelegten schreibgeschützten Zeichenspeicherbereichs an diese Instanz an.Appends the string representation of a specified read-only character memory region to this instance.

Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>) Append(ReadOnlySpan<Char>)

Fügt die Zeichenfolgendarstellung einer festgelegten schreibgeschützten Zeichenspanne an diese Instanz an.Appends the string representation of a specified read-only character span to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen 8-Bit-Ganzzahl mit Vorzeichen an diese Instanz an.Appends the string representation of a specified 8-bit signed integer to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen Gleitkommazahl mit einfacher Genauigkeit an diese Instanz an.Appends the string representation of a specified single-precision floating-point number to this instance.

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

Fügt eine Kopie der angegebenen Zeichenfolge an diese Instanz an.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)

Fügt eine Kopie einer angegebenen Teilzeichenfolge an diese Instanz an.Appends a copy of a specified substring to this instance.

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

Fügt die Zeichenfolgendarstellung eines angegebenen Zeichenfolgengenerators an diese Instanz an.Appends the string representation of a specified string builder to this instance.

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

Fügt eine Kopie einer Teilzeichenfolge im festgelegten Zeichenfolgengenerator an diese Instanz an.Appends a copy of a substring within a specified string builder to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen 16-Bit-Ganzzahl ohne Vorzeichen an diese Instanz an.Appends the string representation of a specified 16-bit unsigned integer to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen 32-Bit-Ganzzahl ohne Vorzeichen an diese Instanz an.Appends the string representation of a specified 32-bit unsigned integer to this instance.

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

Fügt die Zeichenfolgendarstellung einer angegebenen 64-Bit-Ganzzahl ohne Vorzeichen an diese Instanz an.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)

Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines einzigen Arguments mit einem angegebenen Formatanbieter ersetzt.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)

Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines der zwei Argumente mit einem angegebenen Formatanbieter ersetzt.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)

Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines der drei Argumente mit einem angegebenen Formatanbieter ersetzt.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[])

Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Jedes Formatelement wird von der Zeichenfolgendarstellung eines entsprechenden Arguments in einem Parameterarray ersetzt, das einen angegebenen Formatanbieter verwendet.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)

Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines einzelnen Arguments ersetzt.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)

Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Jedes Formatelement wird durch die Zeichenfolgendarstellung für eines von zwei Argumenten ersetzt.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)

Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Jedes Formatelement wird durch die Zeichenfolgendarstellung für eines von drei Argumenten ersetzt.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[])

Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an.Appends the string returned by processing a composite format string, which contains zero or more format items, to this instance. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines entsprechenden Arguments in einem Parameterarray ersetzt.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()

Fügt das Standardzeilenabschlusszeichen am Ende des aktuellen StringBuilder-Objekts an.Appends the default line terminator to the end of the current StringBuilder object.

AppendLine(String) AppendLine(String) AppendLine(String) AppendLine(String)

Fügt eine Kopie der angegebenen Zeichenfolge gefolgt vom Standardzeilenabschlusszeichen am Ende des aktuellen StringBuilder-Objekts an.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()

Entfernt alle Zeichen aus der aktuellen StringBuilder-Instanz.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)

Kopiert die Zeichen aus einem angegebenen Segment dieser Instanz in ein angegebenes Segment eines Ziel-Char-Arrays.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)

Stellt sicher, dass die Kapazität dieser Instanz von StringBuilder mindestens gleich dem angegebenen Wert ist.Ensures that the capacity of this instance of StringBuilder is at least the specified value.

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

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.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>)

Gibt einen Wert zurück, der angibt, ob die Zeichen in dieser Instanz den Zeichen in einer angegebenen schreibgeschützten Zeichenspanne entsprechen.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)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.Returns a value indicating whether this instance is equal to a specified object.

GetChunks() GetChunks() GetChunks() GetChunks()

Gibt ein Objekt zurück, das zum Durchlaufen der Blöcke von Zeichen verwendet werden kann, die in einer ReadOnlyMemory<Char>-Methode dargestellt werden, die aus dieser StringBuilder-Instanz erstellt wurde.Returns an object that can be used to iterate through the chunks of characters represented in a ReadOnlyMemory<Char> created from this StringBuilder instance.

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

Fungiert als Standardhashfunktion.Serves as the default hash function.

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

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
Insert(Int32, Boolean) Insert(Int32, Boolean) Insert(Int32, Boolean) Insert(Int32, Boolean)

Fügt die Zeichenfolgendarstellung eines booleschen Werts an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer angegebenen 8-Bit-Ganzzahl ohne Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung eines angegebenen Unicode-Zeichens an der angegebenen Zeichenposition in diese Instanz ein.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[])

Fügt die Zeichenfolgendarstellung eines angegebenen Arrays von Unicode-Zeichen an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung eines angegebenen Unterarrays von Unicode-Zeichen an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer Dezimalzahl an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer Gleitkommazahl mit doppelter Genauigkeit an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer angegebenen 16-Bit-Ganzzahl mit Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer angegebenen 32-Bit-Ganzzahl mit Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer 64-Bit-Ganzzahl mit Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung eines Objekts an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer angegebenen 8-Bit-Ganzzahl mit Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer Gleitkommazahl mit einfacher Genauigkeit an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt eine Zeichenfolge an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt eine oder mehrere Kopien einer angegebenen Zeichenfolge an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer 16-Bit-Ganzzahl ohne Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer 32-Bit-Ganzzahl ohne Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein.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)

Fügt die Zeichenfolgendarstellung einer 64-Bit-Ganzzahl ohne Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein.Inserts the string representation of a 64-bit unsigned integer into this instance at the specified character position.

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

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

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

Entfernt den angegebenen Bereich von Zeichen aus dieser Instanz.Removes the specified range of characters from this instance.

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

Ersetzt in dieser Instanz alle Vorkommen eines angegebenen Zeichens durch ein anderes angegebenes Zeichen.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)

Ersetzt alle Vorkommen eines angegebenen Zeichens in einer Teilzeichenfolge dieser Instanz durch ein anderes angegebenes Zeichen.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)

Ersetzt in dieser Instanz alle Vorkommen einer angegebenen Zeichenfolge durch eine andere angegebene Zeichenfolge.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)

Ersetzt alle Vorkommen einer angegebenen Zeichenfolge in einer Teilzeichenfolge dieser Instanz durch eine andere angegebene Zeichenfolge.Replaces, within a substring of this instance, all occurrences of a specified string with another specified string.

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

Konvertiert den Wert dieser Instanz in einen String.Converts the value of this instance to a String.

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

Konvertiert den Wert einer Teilzeichenfolge dieser Instanz in eine String.Converts the value of a substring of this instance to a String.

Explizite Schnittstellenimplementierungen

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

Füllt ein SerializationInfo-Objekt mit den Daten, die erforderlich sind, um das aktuelle StringBuilder-Objekt zu deserialisieren.Populates a SerializationInfo object with the data necessary to deserialize the current StringBuilder object.

Gilt für:

Siehe auch