StringBuilder Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt eine veränderbare Zeichenfolge dar. Diese Klasse kann nicht vererbt werden.
public ref class StringBuilder sealedpublic ref class StringBuilder sealed : System::Runtime::Serialization::ISerializablepublic sealed class StringBuilderpublic sealed class StringBuilder : System.Runtime.Serialization.ISerializable[System.Serializable]
public sealed class StringBuilder[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class StringBuilder : System.Runtime.Serialization.ISerializabletype StringBuilder = classtype StringBuilder = class
interface ISerializable[<System.Serializable>]
type StringBuilder = class[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type StringBuilder = class
interface ISerializablePublic NotInheritable Class StringBuilderPublic NotInheritable Class StringBuilder
Implements ISerializable- Vererbung
-
StringBuilder
- Attribute
- Implementiert
Beispiele
Das folgende Beispiel zeigt, wie viele der von der StringBuilder -Klasse definierten Methoden aufgerufen werden.
using namespace System;
using namespace System::Text;
int main()
{
// Create a StringBuilder that expects to hold 50 characters.
// Initialize the StringBuilder with "ABC".
StringBuilder^ sb = gcnew StringBuilder("ABC", 50);
// Append three characters (D, E, and F) to the end of the
// StringBuilder.
sb->Append(gcnew array<Char>{'D', 'E', 'F'});
// Append a format string to the end of the StringBuilder.
sb->AppendFormat("GHI{0}{1}", (Char)'J', (Char)'k');
// Display the number of characters in the StringBuilder
// and its string.
Console::WriteLine("{0} chars: {1}", sb->Length, sb->ToString());
// Insert a string at the beginning of the StringBuilder.
sb->Insert(0, "Alphabet: ");
// Replace all lowercase k's with uppercase K's.
sb->Replace('k', 'K');
// Display the number of characters in the StringBuilder
// and its string.
Console::WriteLine("{0} chars: {1}", sb->Length, sb->ToString());
}
// This code produces the following output.
//
// 11 chars: ABCDEFGHIJk
// 21 chars: Alphabet: ABCDEFGHIJK
using System;
using System.Text;
public sealed class App
{
static void Main()
{
// Create a StringBuilder that expects to hold 50 characters.
// Initialize the StringBuilder with "ABC".
StringBuilder sb = new StringBuilder("ABC", 50);
// Append three characters (D, E, and F) to the end of the StringBuilder.
sb.Append(new char[] { 'D', 'E', 'F' });
// Append a format string to the end of the StringBuilder.
sb.AppendFormat("GHI{0}{1}", 'J', 'k');
// Display the number of characters in the StringBuilder and its string.
Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString());
// Insert a string at the beginning of the StringBuilder.
sb.Insert(0, "Alphabet: ");
// Replace all lowercase k's with uppercase K's.
sb.Replace('k', 'K');
// Display the number of characters in the StringBuilder and its string.
Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString());
}
}
// This code produces the following output.
//
// 11 chars: ABCDEFGHIJk
// 21 chars: Alphabet: ABCDEFGHIJK
open System.Text
// Create a StringBuilder that expects to hold 50 characters.
// Initialize the StringBuilder with "ABC".
let sb = StringBuilder("ABC", 50)
// Append three characters (D, E, and F) to the end of the StringBuilder.
sb.Append [| 'D'; 'E'; 'F' |] |> ignore
// Append a format string to the end of the StringBuilder.
sb.AppendFormat("GHI{0}{1}", 'J', 'k') |> ignore
// Display the number of characters in the StringBuilder and its string.
printfn $"{sb.Length} chars: {sb}"
// Insert a string at the beginning of the StringBuilder.
sb.Insert(0, "Alphabet: ") |> ignore
// Replace all lowercase k's with uppercase K's.
sb.Replace('k', 'K') |> ignore
// Display the number of characters in the StringBuilder and its string.
printfn $"{sb.Length} chars: {sb}"
// This code produces the following output.
//
// 11 chars: ABCDEFGHIJk
// 21 chars: Alphabet: ABCDEFGHIJK
Imports System.Text
Public Module App
Public Sub Main()
' Create a StringBuilder that expects to hold 50 characters.
' Initialize the StringBuilder with "ABC".
Dim sb As New StringBuilder("ABC", 50)
' Append three characters (D, E, and F) to the end of the StringBuilder.
sb.Append(New Char() {"D"c, "E"c, "F"c})
' Append a format string to the end of the StringBuilder.
sb.AppendFormat("GHI{0}{1}", "J"c, "k"c)
' Display the number of characters in the StringBuilder and its string.
Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString())
' Insert a string at the beginning of the StringBuilder.
sb.Insert(0, "Alphabet: ")
' Replace all lowercase k's with uppercase K's.
sb.Replace("k", "K")
' Display the number of characters in the StringBuilder and its string.
Console.WriteLine("{0} chars: {1}", sb.Length, sb.ToString())
End Sub
End Module
' This code produces the following output.
'
' 11 chars: ABCDEFGHIJk
' 21 chars: Alphabet: ABCDEFGHIJK
Hinweise
Diese Klasse stellt ein zeichenfolgenähnliches Objekt dar, dessen Wert eine veränderliche Sequenz von Zeichen ist.
Inhalt dieses Abschnitts:
Die String- und StringBuilder-Typen
Obwohl StringBuilder und String beide Zeichensequenzen darstellen, werden sie unterschiedlich implementiert. String ist ein unveränderlicher Typ. Das heißt, jeder Vorgang, der ein String Objekt zu ändern scheint, erstellt tatsächlich eine neue Zeichenfolge.
Beispielsweise scheint der Aufruf der String.Concat -Methode im folgenden C#-Beispiel den Wert einer Zeichenfolgenvariablen mit dem Namen valuezu ändern. Tatsächlich gibt die Concat -Methode ein value -Objekt zurück, das einen anderen Wert und eine andere Adresse als das value Objekt hat, das an die -Methode übergeben wurde. Beachten Sie, dass das Beispiel mit der /unsafe Compileroption kompiliert werden muss.
using System;
public class Example
{
public unsafe static void Main()
{
string value = "This is the first sentence" + ".";
fixed (char* start = value)
{
value = String.Concat(value, "This is the second sentence. ");
fixed (char* current = value)
{
Console.WriteLine(start == current);
}
}
}
}
// The example displays the following output:
// False
let mutable value = "This is the first sentence" + "."
use start = fixed value
value <- System.String.Concat(value, "This is the second sentence. ")
use current = fixed value
printfn $"{start = current}"
// The example displays the following output:
// False
Bei Routinen, die umfangreiche Zeichenfolgenbearbeitungen durchführen (z. B. Apps, die eine Zeichenfolge mehrmals in einer Schleife ändern), kann das wiederholte Ändern einer Zeichenfolge zu einer erheblichen Leistungseinbuße führen. Die Alternative ist die Verwendung StringBuildervon , bei der es sich um eine veränderliche Zeichenfolgenklasse handelt. Änderbarkeit bedeutet, dass ein instance der Klasse durch Anfügen, Entfernen, Ersetzen oder Einfügen von Zeichen geändert werden kann. Ein StringBuilder -Objekt verwaltet einen Puffer, um Erweiterungen der Zeichenfolge zu berücksichtigen. Neue Daten werden an den Puffer angefügt, wenn Raum verfügbar ist. Andernfalls wird ein neuer, größerer Puffer zugeordnet, Daten aus dem ursprünglichen Puffer in den neuen Puffer kopiert, und die neuen Daten werden dann an den neuen Puffer angefügt.
Wichtig
Obwohl die StringBuilder Klasse im Allgemeinen eine bessere Leistung als die String Klasse bietet, sollten Sie nicht automatisch durch StringBuilder ersetzenString, wenn Sie Zeichenfolgen bearbeiten möchten. Die Leistung hängt von der Größe der Zeichenfolge, der Menge des für die neue Zeichenfolge zuzuweisenden Arbeitsspeichers, dem System, auf dem der Code ausgeführt wird, und dem Typ des Vorgangs ab. Sie sollten bereit sein, Ihren Code zu testen, um festzustellen, ob StringBuilder tatsächlich eine erhebliche Leistungsverbesserung bietet.
Erwägen Sie die Verwendung der String -Klasse unter den folgenden Bedingungen:
Wenn die Anzahl der Änderungen, die Ihr Code an einer Zeichenfolge vor nimmt, klein ist. In diesen Fällen StringBuilder kann eine vernachlässigbare oder keine Leistungsverbesserung gegenüber Stringbieten.
Wenn Sie eine feste Anzahl von Verkettungsvorgängen ausführen, insbesondere mit Zeichenfolgenliteralen. In diesem Fall kann der Compiler die Verkettungsvorgänge in einem einzelnen Vorgang kombinieren.
Wenn Sie umfangreiche Suchvorgänge ausführen müssen, während Sie Ihre Zeichenfolge erstellen. Der StringBuilder -Klasse fehlen Suchmethoden wie
IndexOfoderStartsWith. Sie müssen das StringBuilder -Objekt für diese Vorgänge in ein String konvertieren, und dies kann den Leistungsvorteil der Verwendung von StringBuildernegieren. Weitere Informationen finden Sie im Abschnitt Suchen des Texts in einem StringBuilder-Objekt .
Erwägen Sie die Verwendung der StringBuilder -Klasse unter den folgenden Bedingungen:
Wenn Sie erwarten, dass Ihr Code zur Entwurfszeit eine unbekannte Anzahl von Änderungen an einer Zeichenfolge vorgibt (z. B. wenn Sie eine Schleife verwenden, um eine zufällige Anzahl von Zeichenfolgen zu verketten, die Benutzereingaben enthalten).
Wenn Sie erwarten, dass Ihr Code eine erhebliche Anzahl von Änderungen an einer Zeichenfolge vor sich hat.
Funktionsweise von StringBuilder
Die StringBuilder.Length -Eigenschaft gibt die Anzahl der Zeichen an, die das StringBuilder Objekt derzeit enthält. Wenn Sie dem Objekt Zeichen hinzufügen, nimmt seine StringBuilder Länge zu, bis es der Größe der StringBuilder.Capacity -Eigenschaft entspricht, die die Anzahl der Zeichen definiert, die das Objekt enthalten kann. Wenn die Anzahl der hinzugefügten Zeichen dazu führt, dass die Länge des StringBuilder Objekts seine aktuelle Kapazität überschreitet, wird neuer Arbeitsspeicher zugewiesen, der Wert der Capacity Eigenschaft wird verdoppelt, dem StringBuilder Objekt werden neue Zeichen hinzugefügt, und seine Length Eigenschaft wird angepasst. Zusätzlicher Arbeitsspeicher für das StringBuilder Objekt wird dynamisch zugeordnet, bis es den durch die StringBuilder.MaxCapacity -Eigenschaft definierten Wert erreicht. Wenn die maximale Kapazität erreicht ist, kann dem Objekt kein weiterer Arbeitsspeicher zugewiesen StringBuilder werden, und der Versuch, Zeichen hinzuzufügen oder es über seine maximale Kapazität hinaus zu erweitern, löst entweder eine ArgumentOutOfRangeException Oder eine Ausnahme aus OutOfMemoryException .
Im folgenden Beispiel wird veranschaulicht, wie ein StringBuilder Objekt neuen Arbeitsspeicher zuordnet und seine Kapazität dynamisch erhöht, wenn die dem Objekt zugewiesene Zeichenfolge erweitert wird. Der Code erstellt ein StringBuilder -Objekt durch Aufrufen des (parameterlosen) Standardkonstruktors. Die Standardkapazität dieses Objekts beträgt 16 Zeichen, und die maximale Kapazität beträgt mehr als 2 Milliarden Zeichen. Das Anfügen der Zeichenfolge "This is a sentence." führt zu einer neuen Speicherbelegung, da die Zeichenfolgenlänge (19 Zeichen) die Standardkapazität des StringBuilder Objekts überschreitet. Die Kapazität des Objekts verdoppelt sich auf 32 Zeichen, die neue Zeichenfolge wird hinzugefügt, und die Länge des Objekts beträgt jetzt 19 Zeichen. Der Code fügt dann die Zeichenfolge "Dies ist ein zusätzlicher Satz." 11 Mal an den Wert des StringBuilder Objekts an. Wenn der Anfügevorgang bewirkt, dass die Länge des StringBuilder Objekts seine Kapazität überschreitet, wird seine vorhandene Kapazität verdoppelt, und der Append Vorgang ist erfolgreich.
using System;
using System.Reflection;
using System.Text;
public class Example
{
public static void Main()
{
StringBuilder sb = new StringBuilder();
ShowSBInfo(sb);
sb.Append("This is a sentence.");
ShowSBInfo(sb);
for (int ctr = 0; ctr <= 10; ctr++) {
sb.Append("This is an additional sentence.");
ShowSBInfo(sb);
}
}
private static void ShowSBInfo(StringBuilder sb)
{
foreach (var prop in sb.GetType().GetProperties()) {
if (prop.GetIndexParameters().Length == 0)
Console.Write("{0}: {1:N0} ", prop.Name, prop.GetValue(sb));
}
Console.WriteLine();
}
}
// The example displays the following output:
// Capacity: 16 MaxCapacity: 2,147,483,647 Length: 0
// Capacity: 32 MaxCapacity: 2,147,483,647 Length: 19
// Capacity: 64 MaxCapacity: 2,147,483,647 Length: 50
// Capacity: 128 MaxCapacity: 2,147,483,647 Length: 81
// Capacity: 128 MaxCapacity: 2,147,483,647 Length: 112
// Capacity: 256 MaxCapacity: 2,147,483,647 Length: 143
// Capacity: 256 MaxCapacity: 2,147,483,647 Length: 174
// Capacity: 256 MaxCapacity: 2,147,483,647 Length: 205
// Capacity: 256 MaxCapacity: 2,147,483,647 Length: 236
// Capacity: 512 MaxCapacity: 2,147,483,647 Length: 267
// Capacity: 512 MaxCapacity: 2,147,483,647 Length: 298
// Capacity: 512 MaxCapacity: 2,147,483,647 Length: 329
// Capacity: 512 MaxCapacity: 2,147,483,647 Length: 360
open System.Text
let showSBInfo (sb: StringBuilder) =
for prop in sb.GetType().GetProperties() do
if prop.GetIndexParameters().Length = 0 then
printf $"{prop.Name}: {prop.GetValue sb:N0} "
printfn ""
let sb = StringBuilder()
showSBInfo sb
sb.Append "This is a sentence." |> ignore
showSBInfo sb
for i = 0 to 10 do
sb.Append "This is an additional sentence." |> ignore
showSBInfo sb
// The example displays the following output:
// Capacity: 16 MaxCapacity: 2,147,483,647 Length: 0
// Capacity: 32 MaxCapacity: 2,147,483,647 Length: 19
// Capacity: 64 MaxCapacity: 2,147,483,647 Length: 50
// Capacity: 128 MaxCapacity: 2,147,483,647 Length: 81
// Capacity: 128 MaxCapacity: 2,147,483,647 Length: 112
// Capacity: 256 MaxCapacity: 2,147,483,647 Length: 143
// Capacity: 256 MaxCapacity: 2,147,483,647 Length: 174
// Capacity: 256 MaxCapacity: 2,147,483,647 Length: 205
// Capacity: 256 MaxCapacity: 2,147,483,647 Length: 236
// Capacity: 512 MaxCapacity: 2,147,483,647 Length: 267
// Capacity: 512 MaxCapacity: 2,147,483,647 Length: 298
// Capacity: 512 MaxCapacity: 2,147,483,647 Length: 329
// Capacity: 512 MaxCapacity: 2,147,483,647 Length: 360
Imports System.Reflection
Imports System.Text
Module Example
Public Sub Main()
Dim sb As New StringBuilder()
ShowSBInfo(sb)
sb.Append("This is a sentence.")
ShowSbInfo(sb)
For ctr As Integer = 0 To 10
sb.Append("This is an additional sentence.")
ShowSbInfo(sb)
Next
End Sub
Public Sub ShowSBInfo(sb As StringBuilder)
For Each prop In sb.GetType().GetProperties
If prop.GetIndexParameters().Length = 0 Then
Console.Write("{0}: {1:N0} ", prop.Name, prop.GetValue(sb))
End If
Next
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' Capacity: 16 MaxCapacity: 2,147,483,647 Length: 0
' Capacity: 32 MaxCapacity: 2,147,483,647 Length: 19
' Capacity: 64 MaxCapacity: 2,147,483,647 Length: 50
' Capacity: 128 MaxCapacity: 2,147,483,647 Length: 81
' Capacity: 128 MaxCapacity: 2,147,483,647 Length: 112
' Capacity: 256 MaxCapacity: 2,147,483,647 Length: 143
' Capacity: 256 MaxCapacity: 2,147,483,647 Length: 174
' Capacity: 256 MaxCapacity: 2,147,483,647 Length: 205
' Capacity: 256 MaxCapacity: 2,147,483,647 Length: 236
' Capacity: 512 MaxCapacity: 2,147,483,647 Length: 267
' Capacity: 512 MaxCapacity: 2,147,483,647 Length: 298
' Capacity: 512 MaxCapacity: 2,147,483,647 Length: 329
' Capacity: 512 MaxCapacity: 2,147,483,647 Length: 360
Arbeitsspeicherbelegung
Die Standardkapazität eines StringBuilder Objekts beträgt 16 Zeichen, und die maximale Standardkapazität ist Int32.MaxValue. Diese Standardwerte werden verwendet, wenn Sie die StringBuilder() Konstruktoren und StringBuilder(String) aufrufen.
Sie können die anfängliche Kapazität eines StringBuilder Objekts auf folgende Weise explizit definieren:
Indem Sie einen der Konstruktoren aufrufen, die StringBuilder einen
capacityParameter enthalten, wenn Sie das Objekt erstellen.Durch explizites Zuweisen eines neuen Werts StringBuilder.Capacity zur -Eigenschaft, um ein vorhandenes StringBuilder Objekt zu erweitern. Beachten Sie, dass die -Eigenschaft eine Ausnahme auslöst, wenn die neue Kapazität kleiner als die vorhandene Kapazität oder größer als die maximale Kapazität des StringBuilder Objekts ist.
Durch Aufrufen der StringBuilder.EnsureCapacity -Methode mit der neuen Kapazität. Die neue Kapazität darf nicht größer als die maximale Kapazität des StringBuilder Objekts sein. Im Gegensatz zu einer Zuweisung zur Capacity -Eigenschaft löst jedoch keine Ausnahme aus, EnsureCapacity wenn die gewünschte neue Kapazität kleiner als die vorhandene Kapazität ist. In diesem Fall hat der Methodenaufruf keine Auswirkung.
Wenn die Länge der dem StringBuilder Objekt im Konstruktoraufruf zugewiesenen Zeichenfolge entweder die Standardkapazität oder die angegebene Kapazität überschreitet, wird die Capacity -Eigenschaft auf die Länge der mit dem value -Parameter angegebenen Zeichenfolge festgelegt.
Sie können die maximale Kapazität eines StringBuilder Objekts explizit definieren, indem Sie den StringBuilder(Int32, Int32) -Konstruktor aufrufen. Sie können die maximale Kapazität nicht ändern, indem Sie der MaxCapacity Eigenschaft einen neuen Wert zuweisen, da er schreibgeschützt ist.
Wie im vorherigen Abschnitt gezeigt, wird immer dann, wenn die vorhandene Kapazität unzureichend ist, zusätzlicher Arbeitsspeicher zugewiesen, und die Kapazität eines StringBuilder Objekts verdoppelt sich auf den durch die MaxCapacity -Eigenschaft definierten Wert.
Im Allgemeinen sind die Standardkapazität und die maximale Kapazität für die meisten Apps ausreichend. Sie können erwägen, diese Werte unter den folgenden Bedingungen festzulegen:
Wenn die letztliche Größe des StringBuilder Objekts wahrscheinlich übermäßig groß wird, in der Regel über mehrere Megabyte. In diesem Fall kann es einen gewissen Leistungsvorteil geben, wenn die anfängliche Capacity Eigenschaft auf einen deutlich hohen Wert festgelegt wird, um zu viele Speicherumlagerungen zu vermeiden.
Wenn Ihr Code auf einem System mit eingeschränktem Arbeitsspeicher ausgeführt wird. In diesem Fall sollten Sie erwägen, die MaxCapacity Eigenschaft auf kleiner festzulegen, als Int32.MaxValue wenn Ihr Code große Zeichenfolgen verarbeitet, die dazu führen können, dass er in einer Umgebung mit eingeschränktem Arbeitsspeicher ausgeführt wird.
Instanziieren eines StringBuilder-Objekts
Sie instanziieren ein StringBuilder -Objekt, indem Sie einen seiner sechs überladenen Klassenkonstruktoren aufrufen, die in der folgenden Tabelle aufgeführt sind. Drei der Konstruktoren instanziieren ein StringBuilder Objekt, dessen Wert eine leere Zeichenfolge ist, legen seine Werte und MaxCapacity jedoch anders festCapacity. Die restlichen drei Konstruktoren definieren ein StringBuilder Objekt, das über einen bestimmten Zeichenfolgenwert und eine bestimmte Kapazität verfügt. Zwei der drei Konstruktoren verwenden die standardmäßige maximale Kapazität von Int32.MaxValue, während Sie mit dem dritten die maximale Kapazität festlegen können.
| Konstruktor | Zeichenfolgenwert | Capacity | Maximale Kapazität |
|---|---|---|---|
| StringBuilder() | String.Empty | 16 | Int32.MaxValue |
| StringBuilder(Int32) | String.Empty | Definiert durch den capacity Parameter |
Int32.MaxValue |
| StringBuilder(Int32, Int32) | String.Empty | Definiert durch den capacity Parameter |
Definiert durch den maxCapacity Parameter |
| StringBuilder(String) | Definiert durch den value Parameter |
16 oder value. Length, je nachdem, was größer ist |
Int32.MaxValue |
| StringBuilder(String, Int32) | Definiert durch den value Parameter |
Definiert durch den capacity -Parameter oder value. Length, je nachdem, was größer ist. |
Int32.MaxValue |
| StringBuilder(String, Int32, Int32, Int32) | wird von value definiert Substring(startIndex, length) |
Definiert durch den capacity -Parameter oder value. Length, je nachdem, was größer ist. |
Int32.MaxValue |
Im folgenden Beispiel werden drei dieser Konstruktorüberladungen verwendet, um Objekte zu instanziieren StringBuilder .
using System;
using System.Text;
public class Example
{
public static void Main()
{
string value = "An ordinary string";
int index = value.IndexOf("An ") + 3;
int capacity = 0xFFFF;
// Instantiate a StringBuilder from a string.
StringBuilder sb1 = new StringBuilder(value);
ShowSBInfo(sb1);
// Instantiate a StringBuilder from string and define a capacity.
StringBuilder sb2 = new StringBuilder(value, capacity);
ShowSBInfo(sb2);
// Instantiate a StringBuilder from substring and define a capacity.
StringBuilder sb3 = new StringBuilder(value, index,
value.Length - index,
capacity );
ShowSBInfo(sb3);
}
public static void ShowSBInfo(StringBuilder sb)
{
Console.WriteLine("\nValue: {0}", sb.ToString());
foreach (var prop in sb.GetType().GetProperties()) {
if (prop.GetIndexParameters().Length == 0)
Console.Write("{0}: {1:N0} ", prop.Name, prop.GetValue(sb));
}
Console.WriteLine();
}
}
// The example displays the following output:
// Value: An ordinary string
// Capacity: 18 MaxCapacity: 2,147,483,647 Length: 18
//
// Value: An ordinary string
// Capacity: 65,535 MaxCapacity: 2,147,483,647 Length: 18
//
// Value: ordinary string
// Capacity: 65,535 MaxCapacity: 2,147,483,647 Length: 15
open System.Text
let showSBInfo (sb: StringBuilder) =
for prop in sb.GetType().GetProperties() do
if prop.GetIndexParameters().Length = 0 then
printf $"{prop.Name}: {prop.GetValue sb:N0} "
printfn ""
let value = "An ordinary string"
let index = value.IndexOf "An " + 3
let capacity = 0xFFFF
// Instantiate a StringBuilder from a string.
let sb1 = StringBuilder value
showSBInfo sb1
// Instantiate a StringBuilder from string and define a capacity.
let sb2 = StringBuilder(value, capacity)
showSBInfo sb2
// Instantiate a StringBuilder from substring and define a capacity.
let sb3 = StringBuilder(value, index, value.Length - index, capacity)
showSBInfo sb3
// The example displays the following output:
// Value: An ordinary string
// Capacity: 18 MaxCapacity: 2,147,483,647 Length: 18
//
// Value: An ordinary string
// Capacity: 65,535 MaxCapacity: 2,147,483,647 Length: 18
//
// Value: ordinary string
// Capacity: 65,535 MaxCapacity: 2,147,483,647 Length: 15
Imports System.Text
Module Example
Public Sub Main()
Dim value As String = "An ordinary string"
Dim index As Integer = value.IndexOf("An ") + 3
Dim capacity As Integer = &hFFFF
' Instantiate a StringBuilder from a string.
Dim sb1 As New StringBuilder(value)
ShowSBInfo(sb1)
' Instantiate a StringBuilder from string and define a capacity.
Dim sb2 As New StringBuilder(value, capacity)
ShowSBInfo(sb2)
' Instantiate a StringBuilder from substring and define a capacity.
Dim sb3 As New StringBuilder(value, index,
value.Length - index,
capacity )
ShowSBInfo(sb3)
End Sub
Public Sub ShowSBInfo(sb As StringBuilder)
Console.WriteLine()
Console.WriteLine("Value: {0}", sb.ToString())
For Each prop In sb.GetType().GetProperties
If prop.GetIndexParameters().Length = 0 Then
Console.Write("{0}: {1:N0} ", prop.Name, prop.GetValue(sb))
End If
Next
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' Value: An ordinary string
' Capacity: 18 MaxCapacity: 2,147,483,647 Length: 18
'
' Value: An ordinary string
' Capacity: 65,535 MaxCapacity: 2,147,483,647 Length: 18
'
' Value: ordinary string
' Capacity: 65,535 MaxCapacity: 2,147,483,647 Length: 15
Aufrufen von StringBuilder-Methoden
Die meisten Methoden, die die Zeichenfolge in einem StringBuilder instance ändern, geben einen Verweis auf dieselbe instance zurück. Dadurch können Sie Methoden auf zwei Arten aufrufen StringBuilder :
Sie können einzelne Methodenaufrufe vornehmen und den Rückgabewert ignorieren, wie im folgenden Beispiel.
using System; using System.Text; public class Example { public static void Main() { StringBuilder sb = new StringBuilder(); sb.Append("This is the beginning of a sentence, "); sb.Replace("the beginning of ", ""); sb.Insert(sb.ToString().IndexOf("a ") + 2, "complete "); sb.Replace(",", "."); Console.WriteLine(sb.ToString()); } } // The example displays the following output: // This is a complete sentence.open System.Text let sb = StringBuilder() sb.Append "This is the beginning of a sentence, " |> ignore sb.Replace("the beginning of ", "") |> ignore sb.Insert((string sb).IndexOf "a " + 2, "complete ") |> ignore sb.Replace(",", ".") |> ignore printfn $"{sb}" // The example displays the following output: // This is a complete sentence.Imports System.Text Module Example Public Sub Main() Dim sb As New StringBuilder() sb.Append("This is the beginning of a sentence, ") sb.Replace("the beginning of ", "") sb.Insert(sb.ToString().IndexOf("a ") + 2, "complete ") sb.Replace(",", ".") Console.WriteLine(sb.ToString()) End Sub End Module ' The example displays the following output: ' This is a complete sentence.Sie können eine Reihe von Methodenaufrufen in einer einzelnen Anweisung ausführen. Dies kann praktisch sein, wenn Sie eine einzelne Anweisung schreiben möchten, die aufeinanderfolgende Vorgänge verkettet. Im folgenden Beispiel werden drei Methodenaufrufe aus dem vorherigen Beispiel in einer einzigen Codezeile konsolidiert.
using System; using System.Text; public class Example { public static void Main() { StringBuilder sb = new StringBuilder("This is the beginning of a sentence, "); sb.Replace("the beginning of ", "").Insert(sb.ToString().IndexOf("a ") + 2, "complete ").Replace(",", "."); Console.WriteLine(sb.ToString()); } } // The example displays the following output: // This is a complete sentence.open System.Text let sb = StringBuilder "This is the beginning of a sentence, " sb .Replace("the beginning of ", "") .Insert((string sb).IndexOf "a " + 2, "complete ") .Replace(",", ".") |> ignore printfn $"{sb}" // The example displays the following output: // This is a complete sentence.Imports System.Text Module Example Public Sub Main() Dim sb As New StringBuilder("This is the beginning of a sentence, ") sb.Replace("the beginning of ", "").Insert(sb.ToString().IndexOf("a ") + 2, _ "complete ").Replace(", ", ".") Console.WriteLine(sb.ToString()) End Sub End Module ' The example displays the following output: ' This is a complete sentence.
Ausführen von StringBuilder-Vorgängen
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.
Durchlaufen von StringBuilder-Zeichen
Sie können mithilfe der -Eigenschaft auf die StringBuilder.Chars[] Zeichen in einem StringBuilder -Objekt zugreifen. In C# Chars[] ist ein Indexer; in Visual Basic ist es die Standardeigenschaft der StringBuilder Klasse. Dadurch können Sie einzelne Zeichen nur mithilfe ihres Indexes festlegen oder abrufen, ohne explizit auf die Chars[] -Eigenschaft zu verweisen. Zeichen in einem StringBuilder Objekt beginnen bei Index 0 (Null) und indizieren Length weiter - 1.
Im folgenden Beispiel wird die Chars[] -Eigenschaft veranschaulicht. Es fügt zehn zufällige Zahlen an ein StringBuilder Objekt an und durchläuft dann jedes Zeichen. Wenn die Unicode-Kategorie des Zeichens lautet UnicodeCategory.DecimalDigitNumber, verringert sie die Zahl um 1 (oder ändert die Zahl in 9, wenn der Wert 0 ist). Das Beispiel zeigt den Inhalt des StringBuilder Objekts sowohl vor als auch nach dem Ändern der Werte der einzelnen Zeichen an.
using System;
using System.Globalization;
using System.Text;
public class Example
{
public static void Main()
{
Random rnd = new Random();
StringBuilder sb = new StringBuilder();
// Generate 10 random numbers and store them in a StringBuilder.
for (int ctr = 0; ctr <= 9; ctr++)
sb.Append(rnd.Next().ToString("N5"));
Console.WriteLine("The original string:");
Console.WriteLine(sb.ToString());
// Decrease each number by one.
for (int ctr = 0; ctr < sb.Length; ctr++) {
if (Char.GetUnicodeCategory(sb[ctr]) == UnicodeCategory.DecimalDigitNumber) {
int number = (int) Char.GetNumericValue(sb[ctr]);
number--;
if (number < 0) number = 9;
sb[ctr] = number.ToString()[0];
}
}
Console.WriteLine("\nThe new string:");
Console.WriteLine(sb.ToString());
}
}
// The example displays the following output:
// The original string:
// 1,457,531,530.00000940,522,609.000001,668,113,564.000001,998,992,883.000001,792,660,834.00
// 000101,203,251.000002,051,183,075.000002,066,000,067.000001,643,701,043.000001,702,382,508
// .00000
//
// The new string:
// 0,346,420,429.99999839,411,598.999990,557,002,453.999990,887,881,772.999990,681,559,723.99
// 999090,192,140.999991,940,072,964.999991,955,999,956.999990,532,690,932.999990,691,271,497
// .99999
open System
open System.Globalization
open System.Text
let rnd = Random()
let sb = new StringBuilder()
// Generate 10 random numbers and store them in a StringBuilder.
for _ = 0 to 9 do
rnd.Next().ToString "N5" |> sb.Append |> ignore
printfn "The original string:"
printfn $"{sb}"
// Decrease each number by one.
for i = 0 to sb.Length - 1 do
if Char.GetUnicodeCategory(sb[i]) = UnicodeCategory.DecimalDigitNumber then
let number = Char.GetNumericValue sb.[i] |> int
let number = number - 1
let number = if number < 0 then 9 else number
sb.[i] <- number.ToString()[0]
printfn "\nThe new string:"
printfn $"{sb}"
// The example displays the following output:
// The original string:
// 1,457,531,530.00000940,522,609.000001,668,113,564.000001,998,992,883.000001,792,660,834.00
// 000101,203,251.000002,051,183,075.000002,066,000,067.000001,643,701,043.000001,702,382,508
// .00000
//
// The new string:
// 0,346,420,429.99999839,411,598.999990,557,002,453.999990,887,881,772.999990,681,559,723.99
// 999090,192,140.999991,940,072,964.999991,955,999,956.999990,532,690,932.999990,691,271,497
// .99999
Imports System.Globalization
Imports System.Text
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim sb As New StringBuilder()
' Generate 10 random numbers and store them in a StringBuilder.
For ctr As Integer = 0 To 9
sb.Append(rnd.Next().ToString("N5"))
Next
Console.WriteLine("The original string:")
Console.WriteLine(sb.ToString())
Console.WriteLine()
' Decrease each number by one.
For ctr As Integer = 0 To sb.Length - 1
If Char.GetUnicodeCategory(sb(ctr)) = UnicodeCategory.DecimalDigitNumber Then
Dim number As Integer = CType(Char.GetNumericValue(sb(ctr)), Integer)
number -= 1
If number < 0 Then number = 9
sb(ctr) = number.ToString()(0)
End If
Next
Console.WriteLine("The new string:")
Console.WriteLine(sb.ToString())
End Sub
End Module
' The example displays the following output:
' The original string:
' 1,457,531,530.00000940,522,609.000001,668,113,564.000001,998,992,883.000001,792,660,834.00
' 000101,203,251.000002,051,183,075.000002,066,000,067.000001,643,701,043.000001,702,382,508
' .00000
'
' The new string:
' 0,346,420,429.99999839,411,598.999990,557,002,453.999990,887,881,772.999990,681,559,723.99
' 999090,192,140.999991,940,072,964.999991,955,999,956.999990,532,690,932.999990,691,271,497
' .99999
Das Verwenden von zeichenbasierter Indizierung mit der Chars[]-Eigenschaft kann unter folgenden Bedingungen sehr langsam sein:
- Die StringBuilder-Instanz ist groß, weil sie beispielsweise aus Zehntausenden von Zeichen besteht.
- Die StringBuilder ist "klobig". Das heißt, wiederholte Aufrufe von Methoden, z StringBuilder.Append . B. haben die Eigenschaft des StringBuilder.Capacity Objekts automatisch erweitert und ihm neue Speicherblöcke zugewiesen.
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.
Hinweis
Selbst bei einem großen "blockigen" StringBuilder Objekt hat die Verwendung der -Eigenschaft für den Chars[] indexbasierten Zugriff auf ein oder eine kleine Anzahl von Zeichen eine vernachlässigbare Auswirkung auf die Leistung. In der Regel handelt es sich um einen O(n) -Vorgang. 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.
Wenn Leistungsprobleme auftreten, wenn Sie die zeichenbasierte Indizierung mit StringBuilder-Objekten verwenden, können Sie eine der folgenden Problemumgehungen anwenden:
Konvertieren Sie die StringBuilder-Instanz zu String, indem Sie die ToString-Methode aufrufen. Greifen Sie dann auf die Zeichen in der Zeichenfolge zu.
Kopieren Sie die Inhalte des vorhandenen StringBuilder-Objekts in ein neues StringBuilder-Objekt mit vorab festgelegter Größe. Die Leistung verbessert sich, da das neue StringBuilder-Objekt nicht „blockweise“ strukturiert ist. Beispiel:
// 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. Beachten Sie, dass dadurch der gesamte Arbeitsspeicherblock zugeordnet wird, auch wenn StringBuilder selten die maximale Kapazität erreicht.
Hinzufügen von Text zu einem StringBuilder-Objekt
Die StringBuilder -Klasse umfasst die folgenden Methoden zum Erweitern des Inhalts eines StringBuilder Objekts:
Die Append Methode fügt eine Zeichenfolge, eine Teilzeichenfolge, ein Zeichenarray, einen Teil eines Zeichenarrays, ein einzelnes Zeichen, das mehrmals wiederholt wird, oder die Zeichenfolgendarstellung eines primitiven Datentyps an ein StringBuilder Objekt an.
Die AppendLine -Methode fügt ein Zeilenabschlusszeichen oder eine Zeichenfolge zusammen mit einem Zeilenabschlussator an ein Objekt an StringBuilder .
Die AppendFormat -Methode fügt eine Zeichenfolge im zusammengesetzten Format an ein Objekt an StringBuilder . Die Zeichenfolgendarstellungen von Objekten, die in der Ergebniszeichenfolge enthalten sind, können die Formatierungskonventionen der aktuellen Systemkultur oder einer angegebenen Kultur widerspiegeln.
Die Insert -Methode fügt eine Zeichenfolge, eine Teilzeichenfolge, mehrere Wiederholungen einer Zeichenfolge, ein Zeichenarray, einen Teil eines Zeichenarrays oder die Zeichenfolgendarstellung eines primitiven Datentyps an einer angegebenen Position im StringBuilder Objekt ein. Die Position wird durch einen nullbasierten Index definiert.
Im folgenden Beispiel werden die AppendMethoden , AppendLine, AppendFormatund Insert verwendet, um den Text eines StringBuilder Objekts zu erweitern.
using System;
using System.Text;
public class Example
{
public static void Main()
{
// Create a StringBuilder object with no text.
StringBuilder sb = new StringBuilder();
// Append some text.
sb.Append('*', 10).Append(" Adding Text to a StringBuilder Object ").Append('*', 10);
sb.AppendLine("\n");
sb.AppendLine("Some code points and their corresponding characters:");
// Append some formatted text.
for (int ctr = 50; ctr <= 60; ctr++) {
sb.AppendFormat("{0,12:X4} {1,12}", ctr, Convert.ToChar(ctr));
sb.AppendLine();
}
// Find the end of the introduction to the column.
int pos = sb.ToString().IndexOf("characters:") + 11 +
Environment.NewLine.Length;
// Insert a column header.
sb.Insert(pos, String.Format("{2}{0,12:X4} {1,12}{2}", "Code Unit",
"Character", "\n"));
// Convert the StringBuilder to a string and display it.
Console.WriteLine(sb.ToString());
}
}
// The example displays the following output:
// ********** Adding Text to a StringBuilder Object **********
//
// Some code points and their corresponding characters:
//
// Code Unit Character
// 0032 2
// 0033 3
// 0034 4
// 0035 5
// 0036 6
// 0037 7
// 0038 8
// 0039 9
// 003A :
// 003B ;
// 003C <
open System
open System.Text
// Create a StringBuilder object with no text.
let sb = StringBuilder()
// Append some text.
sb
.Append('*', 10)
.Append(" Adding Text to a StringBuilder Object ")
.Append('*', 10)
|> ignore
sb.AppendLine "\n" |> ignore
sb.AppendLine "Some code points and their corresponding characters:" |> ignore
// Append some formatted text.
for i = 50 to 60 do
sb.AppendFormat("{0,12:X4} {1,12}", i, Convert.ToChar i) |> ignore
sb.AppendLine() |> ignore
// Find the end of the introduction to the column.
let pos = (string sb).IndexOf("characters:") + 11 + Environment.NewLine.Length
// Insert a column header.
sb.Insert(pos, String.Format("{2}{0,12:X4} {1,12}{2}", "Code Unit", "Character", "\n"))
|> ignore
// Convert the StringBuilder to a string and display it.
printfn $"{sb}"
// The example displays the following output:
// ********** Adding Text to a StringBuilder Object **********
//
// Some code points and their corresponding characters:
//
// Code Unit Character
// 0032 2
// 0033 3
// 0034 4
// 0035 5
// 0036 6
// 0037 7
// 0038 8
// 0039 9
// 003A :
// 003B ;
// 003C <
Imports System.Text
Module Example
Public Sub Main()
' Create a StringBuilder object with no text.
Dim sb As New StringBuilder()
' Append some text.
sb.Append("*"c, 10).Append(" Adding Text to a StringBuilder Object ").Append("*"c, 10)
sb.AppendLine()
sb.AppendLine()
sb.AppendLine("Some code points and their corresponding characters:")
' Append some formatted text.
For ctr = 50 To 60
sb.AppendFormat("{0,12:X4} {1,12}", ctr, Convert.ToChar(ctr))
sb.AppendLine()
Next
' Find the end of the introduction to the column.
Dim pos As Integer = sb.ToString().IndexOf("characters:") + 11 +
Environment.NewLine.Length
' Insert a column header.
sb.Insert(pos, String.Format("{2}{0,12:X4} {1,12}{2}", "Code Unit",
"Character", vbCrLf))
' Convert the StringBuilder to a string and display it.
Console.WriteLine(sb.ToString())
End Sub
End Module
' The example displays the following output:
' ********** Adding Text to a StringBuilder Object **********
'
' Some code points and their corresponding characters:
'
' Code Unit Character
' 0032 2
' 0033 3
' 0034 4
' 0035 5
' 0036 6
' 0037 7
' 0038 8
' 0039 9
' 003A :
' 003B ;
' 003C <
Löschen von Text aus einem StringBuilder-Objekt
Die StringBuilder -Klasse enthält Methoden, die die Größe der aktuellen StringBuilder instance reduzieren können. Die Clear -Methode entfernt alle Zeichen und legt die Length -Eigenschaft auf Null fest. Die Remove -Methode löscht eine angegebene Anzahl von Zeichen ab einer bestimmten Indexposition. Darüber hinaus können Sie Zeichen vom Ende eines StringBuilder Objekts entfernen, indem Sie dessen Length Eigenschaft auf einen Wert festlegen, der kleiner als die Länge des aktuellen instance ist.
Im folgenden Beispiel wird ein Teil des Texts aus einem StringBuilder Objekt entfernt, die resultierende Kapazität, die maximale Kapazität und die Länge der Eigenschaftenwerte angezeigt, und dann wird die Clear -Methode aufgerufen, um alle Zeichen aus dem StringBuilder -Objekt zu entfernen.
using System;
using System.Text;
public class Example
{
public static void Main()
{
StringBuilder sb = new StringBuilder("A StringBuilder object");
ShowSBInfo(sb);
// Remove "object" from the text.
string textToRemove = "object";
int pos = sb.ToString().IndexOf(textToRemove);
if (pos >= 0) {
sb.Remove(pos, textToRemove.Length);
ShowSBInfo(sb);
}
// Clear the StringBuilder contents.
sb.Clear();
ShowSBInfo(sb);
}
public static void ShowSBInfo(StringBuilder sb)
{
Console.WriteLine("\nValue: {0}", sb.ToString());
foreach (var prop in sb.GetType().GetProperties()) {
if (prop.GetIndexParameters().Length == 0)
Console.Write("{0}: {1:N0} ", prop.Name, prop.GetValue(sb));
}
Console.WriteLine();
}
}
// The example displays the following output:
// Value: A StringBuilder object
// Capacity: 22 MaxCapacity: 2,147,483,647 Length: 22
//
// Value: A StringBuilder
// Capacity: 22 MaxCapacity: 2,147,483,647 Length: 16
//
// Value:
// Capacity: 22 MaxCapacity: 2,147,483,647 Length: 0
open System.Text
let showSBInfo (sb: StringBuilder) =
for prop in sb.GetType().GetProperties() do
if prop.GetIndexParameters().Length = 0 then
printf $"{prop.Name}: {prop.GetValue sb:N0} "
printfn ""
let sb = StringBuilder "A StringBuilder object"
showSBInfo sb
// Remove "object" from the text.
let textToRemove = "object"
let pos = (string sb).IndexOf textToRemove
if pos >= 0 then
sb.Remove(pos, textToRemove.Length) |> ignore
showSBInfo sb
// Clear the StringBuilder contents.
sb.Clear() |> ignore
showSBInfo sb
// The example displays the following output:
// Value: A StringBuilder object
// Capacity: 22 MaxCapacity: 2,147,483,647 Length: 22
//
// Value: A StringBuilder
// Capacity: 22 MaxCapacity: 2,147,483,647 Length: 16
//
// Value:
// Capacity: 22 MaxCapacity: 2,147,483,647 Length: 0
Imports System.Text
Module Example
Public Sub Main()
Dim sb As New StringBuilder("A StringBuilder object")
ShowSBInfo(sb)
' Remove "object" from the text.
Dim textToRemove As String = "object"
Dim pos As Integer = sb.ToString().IndexOf(textToRemove)
If pos >= 0
sb.Remove(pos, textToRemove.Length)
ShowSBInfo(sb)
End If
' Clear the StringBuilder contents.
sb.Clear()
ShowSBInfo(sb)
End Sub
Public Sub ShowSBInfo(sb As StringBuilder)
Console.WriteLine()
Console.WriteLine("Value: {0}", sb.ToString())
For Each prop In sb.GetType().GetProperties
If prop.GetIndexParameters().Length = 0 Then
Console.Write("{0}: {1:N0} ", prop.Name, prop.GetValue(sb))
End If
Next
Console.WriteLine()
End Sub
End Module
' The example displays the following output:
' Value: A StringBuilder object
' Capacity: 22 MaxCapacity: 2,147,483,647 Length: 22
'
' Value: A StringBuilder
' Capacity: 22 MaxCapacity: 2,147,483,647 Length: 16
'
' Value:
' Capacity: 22 MaxCapacity: 2,147,483,647 Length: 0
Ändern des Texts in einem StringBuilder-Objekt
Die StringBuilder.Replace -Methode ersetzt alle Vorkommen eines Zeichens oder einer Zeichenfolge im gesamten StringBuilder Objekt oder in einem bestimmten Zeichenbereich. Im folgenden Beispiel wird die Replace -Methode verwendet, um alle Ausrufezeichen (!) im StringBuilder Objekt durch Fragezeichen (?) zu ersetzen.
using System;
using System.Text;
public class Example
{
public static void Main()
{
StringBuilder MyStringBuilder = new StringBuilder("Hello World!");
MyStringBuilder.Replace('!', '?');
Console.WriteLine(MyStringBuilder);
}
}
// The example displays the following output:
// Hello World?
open System.Text
let myStringBuilder = StringBuilder "Hello World!"
myStringBuilder.Replace('!', '?') |> ignore
printfn $"{myStringBuilder}"
// The example displays the following output:
// Hello World?
Imports System.Text
Module Example
Public Sub Main()
Dim MyStringBuilder As New StringBuilder("Hello World!")
MyStringBuilder.Replace("!"c, "?"c)
Console.WriteLine(MyStringBuilder)
End Sub
End Module
' The example displays the following output:
' Hello World?
Durchsuchen des Texts in einem StringBuilder-Objekt
Die StringBuilder -Klasse enthält keine Methoden, die den von String der String.Contains-Klasse bereitgestellten Methoden ähnelnString.IndexOf, und String.StartsWith die es Ihnen ermöglichen, das Objekt nach einem bestimmten Zeichen oder einer Teilzeichenfolge zu durchsuchen. Zum Ermitteln der Anwesenheits- oder Startzeichenposition einer Teilzeichenfolge müssen Sie einen String Wert mithilfe einer Zeichenfolgensuchmethode oder einer regulären Ausdrucksmethode durchsuchen. Es gibt vier Möglichkeiten, solche Suchvorgänge zu implementieren, wie die folgende Tabelle zeigt.
| Verfahren | Vorteile | Nachteile |
|---|---|---|
| Suchen Sie Zeichenfolgenwerte, bevor Sie sie dem StringBuilder Objekt hinzufügen. | Nützlich, um zu bestimmen, ob eine Teilzeichenfolge vorhanden ist. | Kann nicht verwendet werden, wenn die Indexposition einer Teilzeichenfolge wichtig ist. |
| Rufen Sie ToString das zurückgegebene Objekt auf String , und suchen Sie es. | Einfach zu verwenden, wenn Sie den gesamten Text einem StringBuilder Objekt zuweisen und dann mit der Änderung beginnen. | Umständlich, wiederholt aufzurufen ToString , wenn Sie Änderungen vornehmen müssen, bevor der gesamte Text dem StringBuilder -Objekt hinzugefügt wird. Sie müssen daran denken, am Ende des Texts des StringBuilder Objekts zu arbeiten, wenn Sie Änderungen vornehmen. |
| Verwenden Sie die Chars[] -Eigenschaft, um sequenziell einen Zeichenbereich zu durchsuchen. | Nützlich, wenn Sie sich mit einzelnen Zeichen oder einer kleinen Teilzeichenfolge befassen. | Umständlich, wenn die Anzahl der zu durchsuchenden Zeichen groß ist oder die Suchlogik komplex ist. Führt zu sehr schlechter Leistung für Objekte, die durch wiederholte Methodenaufrufe sehr groß geworden sind. |
| Konvertieren Sie das StringBuilder Objekt in ein String -Objekt, und führen Sie Änderungen am String Objekt durch. | Nützlich, wenn die Anzahl der Änderungen gering ist. | Negiert den Leistungsvorteil der StringBuilder -Klasse, wenn die Anzahl der Änderungen groß ist. |
Lassen Sie uns diese Techniken genauer untersuchen.
Wenn das Ziel der Suche darin besteht, zu bestimmen, ob eine bestimmte Teilzeichenfolge vorhanden ist (d. h. wenn Sie nicht an der Position der Teilzeichenfolge interessiert sind), können Sie Zeichenfolgen suchen, bevor Sie sie im StringBuilder -Objekt speichern. Das folgende Beispiel bietet eine mögliche Implementierung. Sie definiert eine
StringBuilderFinderKlasse, deren Konstruktor einen Verweis auf ein StringBuilder Objekt und die Teilzeichenfolge übergeben wird, die in der Zeichenfolge gefunden werden soll. In diesem Fall versucht das Beispiel zu ermitteln, ob die aufgezeichneten Temperaturen in Fahrenheit oder Celsius liegen, und fügt dem Anfang des Objekts den StringBuilder entsprechenden Einführungstext hinzu. Ein Zufallszahlengenerator wird verwendet, um ein Array auszuwählen, das Daten in Grad Celsius oder Grad Fahrenheit enthält.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.9Copen System open System.Text type StringBuilderFinder(sb: StringBuilder, textToFind: string) = member _.SearchAndAppend(stringToSearch: string) = sb.Append stringToSearch |> ignore stringToSearch.Contains textToFind let tempF = [| "47.6F"; "51.3F"; "49.5F"; "62.3F" |] let tempC = [| "21.2C"; "16.1C"; "23.5C"; "22.9C" |] let temps = [| tempF; tempC |] let sb = StringBuilder() let f = StringBuilderFinder(sb, "F") let temperatures = temps[Random.Shared.Next(2)] let mutable baseDate = DateTime(2013, 5, 1) let mutable isFahrenheit = false for temperature in temperatures do if isFahrenheit then sb.AppendFormat("{0:d}: {1}\n", baseDate, temperature) |> ignore else isFahrenheit <- $"{baseDate:d}: {temperature}\n" |> f.SearchAndAppend baseDate <- baseDate.AddDays 1 if isFahrenheit then sb.Insert(0, "Average Daily Temperature in Degrees Fahrenheit") |> ignore sb.Insert(47, "\n\n") |> ignore else sb.Insert(0, "Average Daily Temperature in Degrees Celsius") |> ignore sb.Insert(44, "\n\n") |> ignore printfn $"{sb}" // The example displays output similar to the following: // Average Daily Temperature in Degrees Celsius // // 5/1/2013: 21.2C // 5/2/2013: 16.1C // 5/3/2013: 23.5C // 5/4/2013: 22.9CImports 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.9CRufen Sie die StringBuilder.ToString -Methode auf, um das StringBuilder Objekt in ein String -Objekt zu konvertieren. Sie können die Zeichenfolge mit Methoden wie String.LastIndexOf oder durchsuchen String.StartsWith, oder Sie können reguläre Ausdrücke und die Regex -Klasse verwenden, um nach Mustern zu suchen. Da sowohl -StringObjekte als auch StringBuilder -Objekte UTF-16-Codierung zum Speichern von Zeichen verwenden, sind die Indexpositionen von Zeichen, Teilzeichenfolgen und Übereinstimmungen mit regulären Ausdrücken in beiden Objekten identisch. Auf diese Weise können Sie Methoden verwenden StringBuilder , um Änderungen an derselben Position vorzunehmen, an der sich der Text im String -Objekt befindet.
Hinweis
Wenn Sie diesen Ansatz verwenden, sollten Sie vom Ende des StringBuilder Objekts bis zum Anfang arbeiten, damit Sie das StringBuilder Objekt nicht wiederholt in eine Zeichenfolge konvertieren müssen.
Dieser Ansatz wird anhand des folgenden Beispiels veranschaulicht. Es werden vier Vorkommen jedes Buchstabens des englischen Alphabets in einem StringBuilder -Objekt gespeichert. Anschließend konvertiert er den Text in ein String -Objekt und verwendet einen regulären Ausdruck, um die Anfangsposition jeder vierstelligen Sequenz zu identifizieren. Schließlich wird vor jeder vierstelligen Sequenz mit Ausnahme der ersten Sequenz ein Unterstrich hinzugefügt und das erste Zeichen der Sequenz in Großbuchstaben konvertiert.
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_Zzzzopen System open System.Text open System.Text.RegularExpressions // Create a StringBuilder object with 4 successive occurrences // of each character in the English alphabet. let sb = StringBuilder() for char in 'a' .. 'z' do sb.Append(char, 4) |> ignore // Create a parallel string object. let sbString = string sb // Determine where each new character sequence begins. let pattern = @"(\w)\1+" let matches = Regex.Matches(sbString, pattern) // Uppercase the first occurrence of the sequence, and separate it // from the previous sequence by an underscore character. for i = matches.Count - 1 downto 0 do let m = matches[i] sb[m.Index] <- Char.ToUpper sb[m.Index] if m.Index > 0 then sb.Insert(m.Index, "_") |> ignore // Display the resulting string. let sbString2 = string sb for line = 0 to (sbString2.Length - 1) / 80 do let nChars = if line * 80 + 79 <= sbString2.Length then 80 else sbString2.Length - line * 80 printfn $"{sbString2.Substring(line * 80, nChars)}" // The example displays the following output: // Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_ // Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_ZzzzImports 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_ZzzzVerwenden Sie die StringBuilder.Chars[] -Eigenschaft, um einen Zeichenbereich in einem StringBuilder -Objekt sequenziell zu durchsuchen. Dieser Ansatz ist möglicherweise nicht praktikabel, wenn die Anzahl der zu durchsuchenden Zeichen groß ist oder die Suchlogik besonders komplex ist. Informationen zu den Leistungsauswirkungen des zeichen-für-Zeichen-indexbasierten Zugriffs für sehr große, segmentierte StringBuilder Objekte finden Sie in der Dokumentation für die StringBuilder.Chars[] -Eigenschaft.
Das folgende Beispiel ist in seiner Funktionalität identisch mit dem vorherigen Beispiel, unterscheidet sich jedoch in der Implementierung. Es verwendet die Chars[] -Eigenschaft, um zu erkennen, wenn sich ein Zeichenwert geändert hat, fügt einen Unterstrich an dieser Position ein und konvertiert das erste Zeichen in der neuen Sequenz in Großbuchstaben.
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_Zzzzopen System open System.Text // Create a StringBuilder object with 4 successive occurrences // of each character in the English alphabet. let sb = StringBuilder() for char in 'a' .. 'z' do sb.Append(char, 4) |> ignore // Iterate the text to determine when a new character sequence occurs. let mutable position = 0 let mutable current = '\u0000' while position <= sb.Length - 1 do if sb[position] <> current then current <- sb[position] sb[position] <- Char.ToUpper sb[position] if position > 0 then sb.Insert(position, "_") |> ignore position <- position + 2 else position <- position + 1 // Display the resulting string. let sbString = string sb for line = 0 to (sbString.Length - 1) / 80 do let nChars = if line * 80 + 79 <= sbString.Length then 80 else sbString.Length - line * 80 printfn $"{sbString.Substring(line * 80, nChars)}" // The example displays the following output: // Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_ // Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_ZzzzImports 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_ZzzzSpeichern Sie den gesamten unveränderten Text im StringBuilder -Objekt, rufen Sie die StringBuilder.ToString -Methode auf, um das StringBuilder Objekt in ein String -Objekt zu konvertieren, und führen Sie die Änderungen am String -Objekt aus. Sie können diesen Ansatz verwenden, wenn Sie nur wenige Änderungen vorgenommen haben. Andernfalls können die Kosten für die Arbeit mit unveränderlichen Zeichenfolgen die Leistungsvorteile der Verwendung eines StringBuilder -Objekts beeinträchtigen.
Das folgende Beispiel ist in seiner Funktionalität identisch mit den beiden vorherigen Beispielen, unterscheidet sich jedoch in der Implementierung. Es erstellt ein StringBuilder -Objekt, konvertiert es in ein String -Objekt und verwendet dann einen regulären Ausdruck, um alle verbleibenden Änderungen an der Zeichenfolge auszuführen. Die Regex.Replace(String, String, MatchEvaluator) -Methode verwendet einen Lambdaausdruck, um die Ersetzung für jede Übereinstimmung durchzuführen.
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_Zzzzopen System.Text open System.Text.RegularExpressions // Create a StringBuilder object with 4 successive occurrences // of each character in the English alphabet. let sb = StringBuilder() for char in 'a' .. 'z' do sb.Append(char, 4) |> ignore // Convert it to a string. let sbString = string sb // Use a regex to uppercase the first occurrence of the sequence, // and separate it from the previous sequence by an underscore. let pattern = @"(\w)(\1+)" let sbStringReplaced = Regex.Replace( sbString, pattern, fun m -> (if m.Index > 0 then "_" else "") + m.Groups[ 1 ].Value.ToUpper() + m.Groups[2].Value ) // Display the resulting string. for line = 0 to (sbStringReplaced.Length - 1) / 80 do let nChars = if line * 80 + 79 <= sbStringReplaced.Length then 80 else sbStringReplaced.Length - line * 80 printfn $"{sbStringReplaced.Substring(line * 80, nChars)}" // The example displays the following output: // Aaaa_Bbbb_Cccc_Dddd_Eeee_Ffff_Gggg_Hhhh_Iiii_Jjjj_Kkkk_Llll_Mmmm_Nnnn_Oooo_Pppp_ // Qqqq_Rrrr_Ssss_Tttt_Uuuu_Vvvv_Wwww_Xxxx_Yyyy_ZzzzImports 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
Konvertieren des StringBuilder-Objekts in eine Zeichenfolge
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. Sie führen diese Konvertierung durch, indem Sie die StringBuilder.ToString -Methode aufrufen. Eine Abbildung finden Sie im vorherigen Beispiel, in dem die ToString -Methode aufgerufen wird, um ein StringBuilder Objekt in eine Zeichenfolge zu konvertieren, damit es an eine Methode für reguläre Ausdrücke übergeben werden kann.
Hinweise für Aufrufer
Wenn Sie in .NET Core und in der .NET Framework 4.0 und höher das Objekt instanziieren, indem Sie den StringBuilderStringBuilder(Int32, Int32) Konstruktor aufrufen, kann sowohl die Länge als auch die Kapazität des StringBuilder instance den Wert seiner MaxCapacity Eigenschaft überschreiten. Dies kann insbesondere auftreten, wenn Sie die Append(String) Methoden und AppendFormat(String, Object) aufrufen, um kleine Zeichenfolgen anzufügen.
Konstruktoren
| StringBuilder() |
Initialisiert eine neue Instanz der StringBuilder-Klasse. |
| StringBuilder(Int32) |
Initialisiert eine neue Instanz der StringBuilder-Klasse unter Verwendung der angegebenen Kapazität. |
| 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. |
| StringBuilder(String) |
Initialisiert eine neue Instanz der StringBuilder-Klasse unter Verwendung der angegebenen Zeichenfolge. |
| StringBuilder(String, Int32) |
Initialisiert eine neue Instanz der StringBuilder-Klasse unter Verwendung der angegebenen Zeichenfolge und der angegebenen Kapazität. |
| StringBuilder(String, Int32, Int32, Int32) |
Initialisiert eine neue Instanz der StringBuilder-Klasse unter Verwendung der angegebenen Teilzeichenfolge und der angegebenen Kapazität. |
Eigenschaften
| Capacity |
Ruft die Höchstanzahl von Zeichen ab, die im durch die aktuelle Instanz reservierten Speicher enthalten sein können, oder legt diese fest. |
| Chars[Int32] |
Ruft das Zeichen an der angegebenen Zeichenposition in dieser Instanz ab oder legt dieses fest. |
| Length |
Ruft die Länge des aktuellen StringBuilder-Objekts ab oder legt diese fest. |
| MaxCapacity |
Ruft die maximale Kapazität dieser Instanz ab. |
Methoden
| Append(Boolean) |
Fügt die Zeichenfolgendarstellung eines angegebenen booleschen Werts an diese Instanz an. |
| Append(Byte) |
Fügt die Zeichenfolgendarstellung einer angegebenen 8-Bit-Ganzzahl ohne Vorzeichen an diese Instanz an. |
| Append(Char) |
Fügt die Zeichenfolgendarstellung eines angegebenen Char-Objekts an diese Instanz an. |
| Append(Char*, Int32) |
Fügt ein Array aus Unicode-Zeichen ab einer angegebenen Adresse an diese Instanz an. |
| Append(Char, Int32) |
Fügt eine angegebene Anzahl von Kopien der Zeichenfolgendarstellung eines Unicode-Zeichens an diese Instanz an. |
| Append(Char[]) |
Fügt die Zeichenfolgendarstellung der Unicode-Zeichen in einem angegebenen Array an diese Instanz an. |
| Append(Char[], Int32, Int32) |
Fügt die Zeichenfolgendarstellung eines angegebenen Unterarrays von Unicode-Zeichen an diese Instanz an. |
| Append(Decimal) |
Fügt die Zeichenfolgendarstellung einer angegebenen Dezimalzahl an diese Instanz an. |
| Append(Double) |
Fügt die Zeichenfolgendarstellung einer angegebenen Gleitkommazahl mit doppelter Genauigkeit an diese Instanz an. |
| Append(IFormatProvider, StringBuilder+AppendInterpolatedStringHandler) |
Fügt die angegebene interpolierte Zeichenfolge unter Verwendung des angegebenen Formats an diese instance an. |
| Append(Int16) |
Fügt die Zeichenfolgendarstellung einer angegebenen 16-Bit-Ganzzahl mit Vorzeichen an diese Instanz an. |
| Append(Int32) |
Fügt die Zeichenfolgendarstellung einer angegebenen 32-Bit-Ganzzahl mit Vorzeichen an diese Instanz an. |
| Append(Int64) |
Fügt die Zeichenfolgendarstellung einer angegebenen 64-Bit-Ganzzahl mit Vorzeichen an diese Instanz an. |
| Append(Object) |
Fügt die Zeichenfolgendarstellung eines angegebenen Objekts an diese Instanz an. |
| Append(ReadOnlyMemory<Char>) |
Fügt die Zeichenfolgendarstellung eines festgelegten schreibgeschützten Zeichenspeicherbereichs an diese Instanz an. |
| Append(ReadOnlySpan<Char>) |
Fügt die Zeichenfolgendarstellung einer festgelegten schreibgeschützten Zeichenspanne an diese Instanz an. |
| Append(SByte) |
Fügt die Zeichenfolgendarstellung einer angegebenen 8-Bit-Ganzzahl mit Vorzeichen an diese Instanz an. |
| Append(Single) |
Fügt die Zeichenfolgendarstellung einer angegebenen Gleitkommazahl mit einfacher Genauigkeit an diese Instanz an. |
| Append(String) |
Fügt eine Kopie der angegebenen Zeichenfolge an diese Instanz an. |
| Append(String, Int32, Int32) |
Fügt eine Kopie einer angegebenen Teilzeichenfolge an diese Instanz an. |
| Append(StringBuilder) |
Fügt die Zeichenfolgendarstellung eines angegebenen Zeichenfolgengenerators an diese Instanz an. |
| Append(StringBuilder, Int32, Int32) |
Fügt eine Kopie einer Teilzeichenfolge im festgelegten Zeichenfolgengenerator an diese Instanz an. |
| Append(StringBuilder+AppendInterpolatedStringHandler) |
Fügt die angegebene interpolierte Zeichenfolge an diese instance an. |
| Append(UInt16) |
Fügt die Zeichenfolgendarstellung einer angegebenen 16-Bit-Ganzzahl ohne Vorzeichen an diese Instanz an. |
| Append(UInt32) |
Fügt die Zeichenfolgendarstellung einer angegebenen 32-Bit-Ganzzahl ohne Vorzeichen an diese Instanz an. |
| Append(UInt64) |
Fügt die Zeichenfolgendarstellung einer angegebenen 64-Bit-Ganzzahl ohne Vorzeichen an diese Instanz an. |
| AppendFormat(IFormatProvider, CompositeFormat, Object[]) |
Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines der Argumente mit einem angegebenen Formatanbieter ersetzt. |
| AppendFormat(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>) |
Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines der Argumente mit einem angegebenen Formatanbieter ersetzt. |
| 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. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines einzigen Arguments mit einem angegebenen Formatanbieter ersetzt. |
| 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. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines der zwei Argumente mit einem angegebenen Formatanbieter ersetzt. |
| 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. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines der drei Argumente mit einem angegebenen Formatanbieter ersetzt. |
| 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. Jedes Formatelement wird von der Zeichenfolgendarstellung eines entsprechenden Arguments in einem Parameterarray ersetzt, das einen angegebenen Formatanbieter verwendet. |
| 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. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines einzelnen Arguments ersetzt. |
| 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. Jedes Formatelement wird durch die Zeichenfolgendarstellung für eines von zwei Argumenten ersetzt. |
| 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. Jedes Formatelement wird durch die Zeichenfolgendarstellung für eines von drei Argumenten ersetzt. |
| 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. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines entsprechenden Arguments in einem Parameterarray ersetzt. |
| AppendFormat<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2) |
Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines der Argumente mit einem angegebenen Formatanbieter ersetzt. |
| AppendFormat<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1) |
Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines der Argumente mit einem angegebenen Formatanbieter ersetzt. |
| AppendFormat<TArg0>(IFormatProvider, CompositeFormat, TArg0) |
Fügt die Zeichenfolge, die durch Verarbeitung einer kombinierten Formatzeichenfolge mit 0 (null) oder mehr Formatelementen zurückgegeben wurde, an diese Instanz an. Jedes Formatelement wird durch die Zeichenfolgendarstellung eines der Argumente mit einem angegebenen Formatanbieter ersetzt. |
| AppendJoin(Char, Object[]) |
Verkettet die Zeichenfolgendarstellungen der Elemente im bereitgestellten Array von Objekten, wobei das angegebene als Trennzeichen zu verwendende Zeichen zwischen den einzelnen Elementen verwendet wird, und fügt dann das Ergebnis an die aktuelle Instanz des Zeichenfolgen-Generators an. |
| AppendJoin(Char, String[]) |
Verkettet die Zeichenfolgen des bereitgestellten Arrays, wobei das angegebene als Trennzeichen zu verwendende Zeichen zwischen den einzelnen Zeichenfolgen verwendet wird, und fügt dann das Ergebnis an die aktuelle Instanz des Zeichenfolgen-Generators an. |
| AppendJoin(String, Object[]) |
Verkettet die Zeichenfolgendarstellungen der Elemente im bereitgestellten Array von Objekten, wobei das angegebene Trennzeichen zwischen den einzelnen Elementen verwendet wird, und fügt dann das Ergebnis an die aktuelle Instanz des Zeichenfolgen-Generators an. |
| AppendJoin(String, String[]) |
Verkettet die Zeichenfolgen des bereitgestellten Arrays, wobei das angegebene Trennzeichen zwischen den einzelnen Zeichenfolgen verwendet wird, und fügt dann das Ergebnis an die aktuelle Instanz des Zeichenfolgen-Generators an. |
| AppendJoin<T>(Char, IEnumerable<T>) |
Verkettet die Elemente einer Sammlung und fügt diese an, wobei das angegebene als Trennzeichen zu verwendende Zeichen zwischen den einzelnen Elementen verwendet wird. |
| AppendJoin<T>(String, IEnumerable<T>) |
Verkettet die Elemente einer Sammlung und fügt diese an, wobei das Trennzeichen zwischen den einzelnen Elementen verwendet wird. |
| AppendLine() |
Fügt das Standardzeilenabschlusszeichen am Ende des aktuellen StringBuilder-Objekts an. |
| AppendLine(IFormatProvider, StringBuilder+AppendInterpolatedStringHandler) |
Fügt die angegebene interpolierte Zeichenfolge im angegebenen Format, gefolgt vom Standardzeilenabschlusszeichen, am Ende des aktuellen StringBuilder-Objekts an. |
| AppendLine(String) |
Fügt eine Kopie der angegebenen Zeichenfolge gefolgt vom Standardzeilenabschlusszeichen am Ende des aktuellen StringBuilder-Objekts an. |
| AppendLine(StringBuilder+AppendInterpolatedStringHandler) |
Fügt die angegebene interpolierte Zeichenfolge gefolgt vom Standardabschlusszeichen an das Ende des aktuellen StringBuilder-Objekts an. |
| Clear() |
Entfernt alle Zeichen aus der aktuellen StringBuilder-Instanz. |
| CopyTo(Int32, Char[], Int32, Int32) |
Kopiert die Zeichen aus einem angegebenen Segment dieser Instanz in ein angegebenes Segment eines Ziel-Char-Arrays. |
| CopyTo(Int32, Span<Char>, Int32) |
Kopiert die Zeichen aus einem angegebenen Segment dieser Instanz in eine Ziel-Char-Spanne. |
| EnsureCapacity(Int32) |
Stellt sicher, dass die Kapazität dieser Instanz von StringBuilder mindestens gleich dem angegebenen Wert ist. |
| Equals(Object) |
Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object) |
| 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. |
| Equals(StringBuilder) |
Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist. |
| GetChunks() |
Gibt ein Objekt zurück, das zum Durchlaufen der Blöcke von Zeichen verwendet werden kann, die in einer |
| GetHashCode() |
Fungiert als Standardhashfunktion. (Geerbt von Object) |
| GetType() |
Ruft den Type der aktuellen Instanz ab. (Geerbt von Object) |
| Insert(Int32, Boolean) |
Fügt die Zeichenfolgendarstellung eines booleschen Werts an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Byte) |
Fügt die Zeichenfolgendarstellung einer angegebenen 8-Bit-Ganzzahl ohne Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Char) |
Fügt die Zeichenfolgendarstellung eines angegebenen Unicode-Zeichens an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Char[]) |
Fügt die Zeichenfolgendarstellung eines angegebenen Arrays von Unicode-Zeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Char[], Int32, Int32) |
Fügt die Zeichenfolgendarstellung eines angegebenen Unterarrays von Unicode-Zeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Decimal) |
Fügt die Zeichenfolgendarstellung einer Dezimalzahl an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Double) |
Fügt die Zeichenfolgendarstellung einer Gleitkommazahl mit doppelter Genauigkeit an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Int16) |
Fügt die Zeichenfolgendarstellung einer angegebenen 16-Bit-Ganzzahl mit Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Int32) |
Fügt die Zeichenfolgendarstellung einer angegebenen 32-Bit-Ganzzahl mit Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Int64) |
Fügt die Zeichenfolgendarstellung einer 64-Bit-Ganzzahl mit Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Object) |
Fügt die Zeichenfolgendarstellung eines Objekts an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, ReadOnlySpan<Char>) |
Fügt die Sequenz von Zeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, SByte) |
Fügt die Zeichenfolgendarstellung einer angegebenen 8-Bit-Ganzzahl mit Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, Single) |
Fügt die Zeichenfolgendarstellung einer Gleitkommazahl mit einfacher Genauigkeit an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, String) |
Fügt eine Zeichenfolge an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, String, Int32) |
Fügt eine oder mehrere Kopien einer angegebenen Zeichenfolge an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, UInt16) |
Fügt die Zeichenfolgendarstellung einer 16-Bit-Ganzzahl ohne Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, UInt32) |
Fügt die Zeichenfolgendarstellung einer 32-Bit-Ganzzahl ohne Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| Insert(Int32, UInt64) |
Fügt die Zeichenfolgendarstellung einer 64-Bit-Ganzzahl ohne Vorzeichen an der angegebenen Zeichenposition in diese Instanz ein. |
| MemberwiseClone() |
Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object) |
| Remove(Int32, Int32) |
Entfernt den angegebenen Bereich von Zeichen aus dieser Instanz. |
| Replace(Char, Char) |
Ersetzt in dieser Instanz alle Vorkommen eines angegebenen Zeichens durch ein anderes angegebenes Zeichen. |
| Replace(Char, Char, Int32, Int32) |
Ersetzt alle Vorkommen eines angegebenen Zeichens in einer Teilzeichenfolge dieser Instanz durch ein anderes angegebenes Zeichen. |
| Replace(String, String) |
Ersetzt in dieser Instanz alle Vorkommen einer angegebenen Zeichenfolge durch eine andere angegebene Zeichenfolge. |
| Replace(String, String, Int32, Int32) |
Ersetzt alle Vorkommen einer angegebenen Zeichenfolge in einer Teilzeichenfolge dieser Instanz durch eine andere angegebene Zeichenfolge. |
| ToString() |
Konvertiert den Wert dieser Instanz in einen String. |
| ToString(Int32, Int32) |
Konvertiert den Wert einer Teilzeichenfolge dieser Instanz in eine String. |
Explizite Schnittstellenimplementierungen
| ISerializable.GetObjectData(SerializationInfo, StreamingContext) |
Füllt ein SerializationInfo-Objekt mit den Daten, die erforderlich sind, um das aktuelle StringBuilder-Objekt zu deserialisieren. |
Gilt für:
Weitere Informationen
Feedback
Feedback senden und anzeigen für