Freigeben über

Zeichenfolgen und Zeichenfolgenliterale

  • Artikel

Eine Zeichenfolge ist ein Objekt vom Typ String dessen Wert Text ist. Intern wird der Text als sequenzielle schreibgeschützte Auflistung von Char-Objekten gespeichert. Die Length-Eigenschaft einer Zeichenfolge stellt die Anzahl der darin enthaltenen Char Objekte dar, nicht die Anzahl der Unicode-Zeichen. Verwenden Sie das StringInfo-Objekt, um auf die einzelnen Unicode-Codepunkte in einer Zeichenfolge zuzugreifen.

String im Vergleich zu System.String

In C# ist das schlüsselwort string ein Alias für String; daher sind String und string gleichwertig. Verwenden Sie den bereitgestellten Alias string, da er auch ohne using System;funktioniert. Die String-Klasse bietet viele Methoden zum sicheren Erstellen, Bearbeiten und Vergleichen von Zeichenfolgen. Darüber hinaus überlädt C# einige Operatoren, um gemeinsame Zeichenfolgenoperationen zu vereinfachen. Weitere Informationen über das Schlüsselwort finden Sie unter String. Weitere Informationen zum Typ und den zugehörigen Methoden finden Sie unter String.

Deklarieren und Initialisieren von Zeichenfolgen

Sie können Zeichenfolgen auf verschiedene Arten deklarieren und initialisieren, wie im folgenden Beispiel gezeigt:

// Declare without initializing.
string message1;

// Initialize to null.
string? message2 = null;

// Initialize as an empty string.
// Use the Empty constant instead of the literal "".
string message3 = System.String.Empty;

// Initialize with a regular string literal.
string oldPath = "c:\\Program Files\\Microsoft Visual Studio 8.0";

// Initialize with a verbatim string literal.
string newPath = @"c:\Program Files\Microsoft Visual Studio 9.0";

// Use System.String if you prefer.
System.String greeting = "Hello World!";

// In local variables (i.e. within a method body)
// you can use implicit typing.
var temp = "I'm still a strongly-typed System.String!";

// Use a const string to prevent 'message4' from
// being used to store another string value.
const string message4 = "You can't get rid of me!";

// Use the String constructor only when creating
// a string from a char*, char[], or sbyte*. See
// System.String documentation for details.
char[] letters = { 'A', 'B', 'C' };
string alphabet = new string(letters);

Beachten Sie, dass Sie nicht den new Operator zum Erstellen eines Zeichenfolgenobjekts verwenden, es sein denn, Sie initialisieren die Zeichenfolge mit einem Array von Chars.

Initialisieren Sie eine Zeichenfolge mit dem Konstantenwert Empty, um ein neues String-Objekt zu erstellen, dessen Zeichenfolge eine Länge von null hat. Die Darstellung des Zeichenfolgenliterals einer Zeichenfolge mit einer Länge von 0 ist "". Indem Zeichenfolgen mit dem Wert Empty anstatt NULL initialisiert werden, können Sie die Chancen einer auftretenden NullReferenceException reduzieren. Verwenden Sie die statische IsNullOrEmpty(String)-Methode, um den Wert einer Zeichenfolge zu überprüfen, bevor Sie versuchen, darauf zuzugreifen.

Unveränderlichkeit von Zeichenfolgen

Zeichenfolgenobjekte sind unveränderlich: sie können nicht geändert werden, nachdem sie erstellt wurden. Alle String Methoden und C#-Operatoren, die scheinbar eine Zeichenfolge ändern, geben die Ergebnisse tatsächlich in einem neuen Zeichenfolgenobjekt zurück. Im folgenden Beispiel bleiben die beiden ursprünglichen Zeichenfolgen unverändert, wenn der Inhalt von s1 und s2 verkettet wird, um eine einzelne Zeichenfolge zu bilden. Der Operator += erstellt eine neue Zeichenfolge, die den kombinierten Inhalt enthält. Das neue Objekt wird der Variablen s1 zugewiesen, und das ursprüngliche Objekt, das s1 zugewiesen wurde, wird für die Garbage Collection freigegeben, da keine andere Variable einen Verweis darauf enthält.

string s1 = "A string is more ";
string s2 = "than the sum of its chars.";

// Concatenate s1 and s2. This actually creates a new
// string object and stores it in s1, releasing the
// reference to the original object.
s1 += s2;

System.Console.WriteLine(s1);
// Output: A string is more than the sum of its chars.

Da eine „Zeichenfolgenänderung“ in Wirklichkeit eine neue Erstellung von Zeichenfolgen ist, müssen Sie vorsichtig sein, wenn Sie Verweise auf Zeichenfolgen erstellen. Wenn Sie einen Verweis auf eine Zeichenfolge erstellen und dann die ursprüngliche Zeichenfolge "ändern", zeigt der Verweis weiterhin auf das ursprüngliche Objekt anstelle des neuen Objekts, das beim Ändern der Zeichenfolge erstellt wurde. Der folgende Code veranschaulicht dieses Verhalten:

string str1 = "Hello ";
string str2 = str1;
str1 += "World";

System.Console.WriteLine(str2);
//Output: Hello

Weitere Informationen zum Erstellen neuer Zeichenfolgen, die auf Änderungen wie Such- und Ersetzungsvorgängen in der ursprünglichen Zeichenfolge basieren, finden Sie unter Ändern von Zeichenfolgeninhalten.

Zeichenfolgenliterale in Anführungszeichen

Zeichenfolgenliterale mit Anführungszeichen beginnen und enden mit einem einfachen doppelten Anführungszeichen (") in derselben Zeile. Zeichenfolgenliterale in Anführungszeichen eignen sich am besten für Zeichenfolgen, die in eine einzelne Zeile passen und keine Escapesequenzen enthalten. Ein Zeichenfolgenliteral in Anführungszeichen muss Escapezeichen einbetten, wie im folgenden Beispiel gezeigt:

string columns = "Column 1\tColumn 2\tColumn 3";
//Output: Column 1        Column 2        Column 3

string rows = "Row 1\r\nRow 2\r\nRow 3";
/* Output:
    Row 1
    Row 2
    Row 3
*/

string title = "\"The \u00C6olean Harp\", by Samuel Taylor Coleridge";
//Output: "The Æolean Harp", by Samuel Taylor Coleridge

Ausführliche Zeichenfolgeliterale

Ausführliche Zeichenfolgenliterale sind für mehrzeilige Zeichenfolgen, Zeichenfolgen mit umgekehrtem Schrägstrich oder eingebettete doppelte Anführungszeichen besser geeignet. Ausführliche Zeichenfolgen behalten Zeilenumbrüche als Teil des Zeichenfolgentexts bei. Verwenden Sie doppelte Anführungszeichen, um ein Anführungszeichen in eine ausführliche Zeichenfolge einzubetten. Das folgende Beispiel zeigt einige häufige Verwendungsmöglichkeiten für wörtliche Zeichenfolgen.

string title = "\"The \u00C6olean Harp\", by Samuel Taylor Coleridge";
//Output: "The Æolean Harp", by Samuel Taylor Coleridge

string filePath = @"C:\Users\scoleridge\Documents\";
//Output: C:\Users\scoleridge\Documents\

string text = @"My pensive SARA ! thy soft cheek reclined
    Thus on mine arm, most soothing sweet it is
    To sit beside our Cot,...";
/* Output:
My pensive SARA ! thy soft cheek reclined
    Thus on mine arm, most soothing sweet it is
    To sit beside our Cot,...
*/

string quote = @"Her name was ""Sara.""";
//Output: Her name was "Sara."

Unformatierten Zeichenfolgenliterale

Ab C# 11 können Sie Rohzeichenfolgenliterale verwenden, um einfacher Zeichenfolgen zu erstellen, die mehrzeilig sind oder alle Zeichen verwenden, die Escapesequenzen erfordern. Rohzeichenfolgenliterale machen die Verwendung von Escapesequenzen überflüssig. Sie können die Zeichenfolge schreiben, einschließlich Leerzeichenformatierung, wie sie in der Ausgabe angezeigt werden soll. Ein Rohzeichenfolgenliteral:

  • Beginnt und endet mit einer Sequenz von mindestens drei doppelten Anführungszeichen ("""). Sie können die Sequenz mit mehr als drei aufeinanderfolgenden Zeichen beginnen und beenden, um Zeichenfolgenliterale zu unterstützen, die drei (oder mehr) wiederholte Anführungszeichen enthalten.
  • Bei einzeiligen Rohzeichenfolgenliteralen müssen die öffnenden und schließenden Anführungszeichen in derselben Zeile stehen.
  • Bei mehrzeiligen Rohzeichenfolgenliteralen müssen die öffnenden und schließenden Anführungszeichen in der entsprechenden Zeile stehen.
  • In mehrzeiligen Rohzeichenfolgenliteralen werden alle Leerzeichen vor den schließenden Anführungszeichen aus allen Zeilen des Rohzeichenfolgenliterals entfernt.
  • In mehrzeiligen Rohzeichenfolgenliteralen wird das Leerzeichen nach dem öffnenden Anführungszeichen in derselben Zeile ignoriert.
  • In mehrzeiligen Rohzeichenfolgenliteralen werden Leerzeichenzeilen, die dem öffnenden Anführungszeichen folgen, im Zeichenfolgenliteral einbezogen.

Die folgenden Beispiele veranschaulichen diese Regeln:

string singleLine = """Friends say "hello" as they pass by.""";
string multiLine = """
    "Hello World!" is typically the first program someone writes.
    """;
string embeddedXML = """
       <element attr = "content">
           <body style="normal">
               Here is the main text
           </body>
           <footer>
               Excerpts from "An amazing story"
           </footer>
       </element >
       """;
// The line "<element attr = "content">" starts in the first column.
// All whitespace left of that column is removed from the string.

string rawStringLiteralDelimiter = """"
    Raw string literals are delimited 
    by a string of at least three double quotes,
    like this: """
    """";

Die folgenden Beispiele veranschaulichen die auf der Grundlage dieser Regeln gemeldeten Compilerfehler:

// CS8997: Unterminated raw string literal.
var multiLineStart = """This
    is the beginning of a string 
    """;

// CS9000: Raw string literal delimiter must be on its own line.
var multiLineEnd = """
    This is the beginning of a string """;

// CS8999: Line does not start with the same whitespace as the closing line
// of the raw string literal
var noOutdenting = """
    A line of text.
Trying to outdent the second line.
    """;

Die ersten beiden Beispiele sind ungültig, da sich die öffnende und schließende Anführungszeichensequenz bei mehrzeiligen Rohzeichenfolgenliteralen in einer eigenen Zeile befinden müssen. Das dritte Beispiel ist ungültig, da der Text aus der schließenden Anführungszeichensequenz ausgerückt wird.

Sie sollten Rohzeichenfolgenliterale in Betracht ziehen, wenn Sie Text mit Zeichen generieren, die Escapesequenzen erfordern, wenn Sie Zeichenfolgenliterale in Anführungszeichen oder ausführliche Zeichenfolgenliterale verwenden. Rohzeichenfolgenliterale sind für Sie und andere einfacher zu lesen, da sie mehr Ähnlichkeit mit dem Ausgabetext haben. Betrachten Sie beispielsweise den folgenden Code, der eine Zeichenfolge mit formatiertem JSON enthält:

string jsonString = """
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureCelsius": 25,
  "Summary": "Hot",
  "DatesAvailable": [
    "2019-08-01T00:00:00-07:00",
    "2019-08-02T00:00:00-07:00"
  ],
  "TemperatureRanges": {
    "Cold": {
      "High": 20,
      "Low": -10
    },
    "Hot": {
      "High": 60,
      "Low": 20
    }
            },
  "SummaryWords": [
    "Cool",
    "Windy",
    "Humid"
  ]
}
""";

Escapesequenzen für Zeichenfolgen

Escapesequenz Charaktername Unicode-Codierung
\' Einfaches Anführungszeichen 0x0027
\" Doppeltes Anführungszeichen 0x0022
\\ Backslash 0x005C
\0 Null 0x0000
\a Warnung 0x0007
\b Rückschritt 0x0008
\e Flucht 0x001B
\f Seitenvorschub 0x000C
\n Zeilenwechsel 0x000A
\r Wagenrücklauf 0x000D
\t Horizontaler Tabulator 0x0009
\v Vertikaler Tabulator 0x000B
\u Unicode-Escapesequenz (UTF-16) \uHHHH (Bereich: 0000 - FFFF; Beispiel: \u00E7 = "ç")
\U Unicode-Escapesequenz (UTF-32) \U00HHHHHH (Bereich: 000000 - 10FFFF; Beispiel: \U0001F47D = "👽")
\x Unicode-Escapesequenz ähnlich wie "\u", aber mit variabler Länge \xH[H][H][H] (Bereich: 0 - FFFF; Beispiel: \x00E7 oder \x0E7 oder \xE7 = "ç")

Warnung

Wenn Sie die \x-Escapesequenz verwenden und weniger als vier Hexadezimalziffern angeben, werden die Zeichen, die unmittelbar auf die Escapesequenz folgen, als Teil der Escapesequenz interpretiert, sofern diese Zeichen gültige Hexadezimalziffern sind (d. h. 0-9, A-F und a-f). Beispielsweise erzeugt \xA1 "¡", d. h. Codepunkt U+00A1. Wenn das nächste Zeichen jedoch "A" oder "a" ist, wird die Escapesequenz stattdessen als \xA1A interpretiert und "ਚ" erzeugt (entspricht dem Codepunkt U+0A1A). In solchen Fällen verhindert die Angabe aller vier Hexziffern (z. B. \x00A1) mögliche Fehlinterpretation.

Anmerkung

Zum Zeitpunkt der Kompilierung werden ausführliche und unformatierte Zeichenfolgen in normale Zeichenfolgen mit gleichen Escapesequenzen konvertiert. Aus diesem Grund sehen Sie die Escapezeichen, die vom Compiler hinzugefügt werden, und nicht die ausführliche oder unformatierte Version aus Ihrem Sourcecode, wenn Sie eine ausführliche oder unformatierte Zeichenfolge in Debugger-Überwachungsfenster anzeigen. Die ausführliche Zeichenfolge @"C:\files.txt" wird im Überwachungsfenster z.B. als "C:\\files.txt" angezeigt.

Formatzeichenfolgen

Eine Formatzeichenfolge ist eine Zeichenfolge, deren Inhalt zur Laufzeit dynamisch bestimmt wird. Formatzeichenfolgen werden erstellt, indem interpolierte Ausdrücke oder Platzhalter in geschweifte Klammern innerhalb einer Zeichenfolge eingebettet werden. Alles, was sich innerhalb der geschweiften Klammern ({...}) befindet, wird zu einem Wert aufgelöst und zur Laufzeit als formatierte Zeichenfolge ausgegeben. Es gibt zwei Methoden zum Erstellen von Formatzeichenfolgen: Stringinterpolation und zusammengesetzte Formatierung.

Zeichenfolgeninterpolierung

Sie deklarieren Interpolierte Zeichenfolgen mit dem $ Sonderzeichen. Eine interpolierte Zeichenfolge enthält interpolierte Ausdrücke in geschweiften Klammern. Wenn Sie noch nicht mit der Zeichenfolgeninterpolation vertraut sind, erhalten Sie im interaktiven Tutorial Zeichenfolgeninterpolation in C# eine kurze Übersicht.

Verwenden Sie die Interpolation von Zeichenfolgen, um die Lesbarkeit und Wartung ihres Codes zu verbessern. Mit der Zeichenfolgeninterpolation werden die gleichen Ergebnisse erzielt wie mit der String.Format-Methode, es wird jedoch die Benutzerfreundlichkeit und Übersichtlichkeit verbessert.

var jh = (firstName: "Jupiter", lastName: "Hammon", born: 1711, published: 1761);
Console.WriteLine($"{jh.firstName} {jh.lastName} was an African American poet born in {jh.born}.");
Console.WriteLine($"He was first published in {jh.published} at the age of {jh.published - jh.born}.");
Console.WriteLine($"He'd be over {Math.Round((2018d - jh.born) / 100d) * 100d} years old today.");

// Output:
// Jupiter Hammon was an African American poet born in 1711.
// He was first published in 1761 at the age of 50.
// He'd be over 300 years old today.

Sie können die Zeichenfolgeninterpolation verwenden, um eine konstante Zeichenfolge zu initialisieren, wenn alle Ausdrücke, die als Platzhalter verwendet werden, ebenfalls konstante Zeichenfolgen sind.

Ab C# 11 können Sie unformatierte Zeichenfolgenliterale mit Zeichenfolgeninterpolationen kombinieren. Die Formatzeichenfolge beginnt und endet mit mindestens drei aufeinanderfolgenden doppelten Anführungszeichen. Wenn die Ausgabezeichenfolge das Zeichen { oder } enthalten soll, können Sie zusätzliche $-Zeichen verwenden, um anzugeben, wie viele {- und }-Zeichen eine Interpolation beginnen und beenden. Jede Sequenz von weniger {- oder }-Zeichen ist in der Ausgabe enthalten. Das folgende Beispiel zeigt, wie Sie diese Funktion verwenden können, um den Abstand eines Punkts vom Ursprung anzuzeigen und den Punkt in geschweifte Klammern zu setzen.

int X = 2;
int Y = 3;

var pointMessage = $$"""The point {{{X}}, {{Y}}} is {{Math.Sqrt(X * X + Y * Y)}} from the origin.""";

Console.WriteLine(pointMessage);
// Output:
// The point {2, 3} is 3.605551275463989 from the origin.

Verbatim-Zeichenfolgen-Interpolation

C# ermöglicht auch die Interpolation von wortwörtlichen Zeichenfolgen, z. B. über mehrere Zeilen hinweg, mithilfe der Syntax $@ oder @$.

Verwenden Sie ein ausführliches Zeichenfolgenliteral, um Escapesequenzen wörtlich zu interpretieren. Eine interpolierte Verbatim-Zeichenfolge beginnt mit dem Zeichen $, gefolgt von dem Zeichen @. Sie können die Token $ und @ in beliebiger Reihenfolge verwenden: Sowohl $@"..." als auch $@"..." sind gültige interpolierte ausführliche Zeichenfolgen.

var jh = (firstName: "Jupiter", lastName: "Hammon", born: 1711, published: 1761);
Console.WriteLine($@"{jh.firstName} {jh.lastName}
    was an African American poet born in {jh.born}.");
Console.WriteLine(@$"He was first published in {jh.published}
at the age of {jh.published - jh.born}.");

// Output:
// Jupiter Hammon
//     was an African American poet born in 1711.
// He was first published in 1761
// at the age of 50.

Kombinierte Formatierung

String.Format verwendet Platzhalter in geschweiften Klammern, um eine Formatzeichenfolge zu erstellen. Dieses Beispiel führt zu einer ähnlichen Ausgabe wie die der Zeichenfolgeninterpolationsmethode, die im vorherigen Beispiel verwendet wird.

var pw = (firstName: "Phillis", lastName: "Wheatley", born: 1753, published: 1773);
Console.WriteLine("{0} {1} was an African American poet born in {2}.", pw.firstName, pw.lastName, pw.born);
Console.WriteLine("She was first published in {0} at the age of {1}.", pw.published, pw.published - pw.born);
Console.WriteLine("She'd be over {0} years old today.", Math.Round((2018d - pw.born) / 100d) * 100d);

// Output:
// Phillis Wheatley was an African American poet born in 1753.
// She was first published in 1773 at the age of 20.
// She'd be over 300 years old today.

Weitere Informationen zum Formatieren von .NET-Typen finden Sie unter Formatieren von Typen in .NET.

Teilzeichenfolgen

Eine Teilzeichenfolge ist eine beliebige Sequenz von Zeichen, die in einer Zeichenfolge enthalten ist. Verwenden Sie die Substring-Methode, um eine neue Zeichenfolge aus einem Teil der ursprünglichen Zeichenfolge zu erstellen. Sie können mithilfe der IndexOf-Methode nach einem oder mehreren Vorkommen einer Teilzeichenfolge suchen. Verwenden Sie die Replace-Methode, um alle Vorkommen einer angegebenen Teilzeichenfolge durch eine neue Zeichenfolge zu ersetzen. Wie die Substring-Methode gibt Replace tatsächlich eine neue Zeichenfolge zurück und ändert die ursprüngliche Zeichenfolge nicht. Weitere Informationen finden Sie unter Wie man Zeichenfolgen durchsucht und Wie man Zeichenfolgeninhalte ändert.

string s3 = "Visual C# Express";
System.Console.WriteLine(s3.Substring(7, 2));
// Output: "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic"));
// Output: "Visual Basic Express"

// Index values are zero-based
int index = s3.IndexOf("C");
// index = 7

Zugreifen auf einzelne Zeichen

Sie können die Arraynotation mit einem Indexwert verwenden, um schreibgeschützten Zugriff auf einzelne Zeichen zu erhalten, so wie in folgendem Beispiel gezeigt:

string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)
{
    System.Console.Write(s5[s5.Length - i - 1]);
}
// Output: "sdrawkcab gnitnirP"

Wenn die String-Methoden nicht die Funktionalität bereitstellen, die Sie zum Ändern einzelner Zeichen in einer Zeichenfolge benötigen, können Sie ein StringBuilder-Objekt verwenden, um die einzelnen Zeichen "direkt" zu ändern, und dann eine neue Zeichenfolge erstellen, um die Ergebnisse mithilfe der StringBuilder Methoden zu speichern. Gehen Sie im folgenden Beispiel davon aus, dass Sie die ursprüngliche Zeichenfolge auf eine bestimmte Weise ändern und dann die Ergebnisse für die zukünftige Verwendung speichern müssen:

string question = "hOW DOES mICROSOFT wORD DEAL WITH THE cAPS lOCK KEY?";
System.Text.StringBuilder sb = new System.Text.StringBuilder(question);

for (int j = 0; j < sb.Length; j++)
{
    if (System.Char.IsLower(sb[j]) == true)
        sb[j] = System.Char.ToUpper(sb[j]);
    else if (System.Char.IsUpper(sb[j]) == true)
        sb[j] = System.Char.ToLower(sb[j]);
}
// Store the new string.
string corrected = sb.ToString();
System.Console.WriteLine(corrected);
// Output: How does Microsoft Word deal with the Caps Lock key?

Nullzeichenfolgen und leere Zeichenfolgen

Eine leere Zeichenfolge ist eine Instanz eines System.String-Objekts, das keine Zeichen enthält. Leere Zeichenfolgen werden häufig in verschiedenen Programmierszenarien verwendet, um ein leeres Textfeld darzustellen. Sie können Methoden für leere Zeichenfolgen aufrufen, weil sie gültige System.String-Objekte sind. Leere Zeichenfolgen werden wie folgt initialisiert:

string s = String.Empty;

Im Gegensatz dazu verweist eine NULL-Zeichenfolge nicht auf eine Instanz eines System.String Objekts, und jeder Versuch, eine Methode für eine NULL-Zeichenfolge aufzurufen, verursacht eine NullReferenceException. Sie können jedoch NULL-Zeichenfolgen in Verkettungs- und Vergleichsvorgängen mit anderen Zeichenfolgen verwenden. Die folgenden Beispiele veranschaulichen einige Fälle, in denen ein Verweis auf eine null-Zeichenfolge eine Ausnahme auslöst oder nicht:

string str = "hello";
string? nullStr = null;
string emptyStr = String.Empty;

string tempStr = str + nullStr;
// Output of the following line: hello
Console.WriteLine(tempStr);

bool b = (emptyStr == nullStr);
// Output of the following line: False
Console.WriteLine(b);

// The following line creates a new empty string.
string newStr = emptyStr + nullStr;

// Null strings and empty strings behave differently. The following
// two lines display 0.
Console.WriteLine(emptyStr.Length);
Console.WriteLine(newStr.Length);
// The following line raises a NullReferenceException.
//Console.WriteLine(nullStr.Length);

// The null character can be displayed and counted, like other chars.
string s1 = "\x0" + "abc";
string s2 = "abc" + "\x0";
// Output of the following line: * abc*
Console.WriteLine("*" + s1 + "*");
// Output of the following line: *abc *
Console.WriteLine("*" + s2 + "*");
// Output of the following line: 4
Console.WriteLine(s2.Length);

Verwenden von StringBuilder für schnelle Zeichenfolgenerstellung

Zeichenfolgenvorgänge in .NET sind hoch optimiert und wirken sich in den meisten Fällen nicht erheblich auf die Leistung aus. In einigen Szenarios, z.B. in engen Schleifen, die Hunderttausende Male ausgeführt werden, können sich Zeichenfolgenoperationen auf die Leistung auswirken. Die StringBuilder-Klasse erstellt einen Zeichenfolgenpuffer, der eine bessere Leistung bietet, wenn ihr Programm viele Zeichenfolgenmanipulationen durchführt. Mit der StringBuilder-Zeichenfolge können Sie auch einzelne Zeichen erneut zuweisen, was der integrierte String-Datentyp nicht unterstützt. Dieser Code ändert z. B. den Inhalt einer Zeichenfolge, ohne eine neue Zeichenfolge zu erstellen:

System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet");
sb[0] = 'C';
System.Console.WriteLine(sb.ToString());
//Outputs Cat: the ideal pet

In diesem Beispiel wird ein StringBuilder-Objekt verwendet, um einen String aus verschiedenen numerischen Typen zu erstellen.

var sb = new StringBuilder();

// Create a string composed of numbers 0 - 9
for (int i = 0; i < 10; i++)
{
    sb.Append(i.ToString());
}
Console.WriteLine(sb);  // displays 0123456789

// Copy one character of the string (not possible with a System.String)
sb[0] = sb[9];

Console.WriteLine(sb);  // displays 9123456789

Zeichenfolgen, Erweiterungsmethoden und LINQ

Da der String-Typ IEnumerable<T>implementiert, können Sie die in der Enumerable-Klasse definierten Erweiterungsmethoden für Zeichenfolgen verwenden. Um visuelle Unordnung zu vermeiden, werden diese Methoden von IntelliSense für den Typ String ausgeschlossen, sind aber dennoch verfügbar. Sie können auch LINQ-Abfrageausdrücke für Zeichenfolgen verwenden. Weitere Informationen finden Sie unter LINQ und Zeichenfolgen.