C#-Zeichenfolgen

Tip

Dieser Artikel ist Teil des Abschnitts "Grundlagen" für Entwickler, die bereits mindestens eine Programmiersprache kennen und C# erlernen. Wenn Sie noch nicht mit der Programmierung vertraut sind, beginnen Sie zuerst mit den Lernprogrammen " Erste Schritte ".

Kommen Sie von Java oder C++? Ein C# string ist ein unveränderlicher Referenztyp, der auf String basiert. UTF-16 ist die In-Memory-Codierung, ähnlich wie die String von Java. Im Gegensatz zu C/C++ werden Zeichenfolgen nicht null-beendet und verfallen nicht in Zeiger.

Eine Zeichenfolge ist eine Abfolge von Zeichen. In C# ist string das Sprachschlüsselwort für den Typ System.String. Jedes Stringliteral, das Sie schreiben, erzeugt eine System.String-Instanz.

string im Vergleich zu String

Das string Schlüsselwort und der String Typname beziehen sich auf denselben Typ. Sie werden in identischer Zwischensprache (IL) kompiliert.

// The 'string' keyword is an alias for System.String. The two are identical.
string a = "hello";
String b = "hello";

Console.WriteLine(a == b);                // True
Console.WriteLine(typeof(string) == typeof(String)); // True

Bevorzugen Sie das string Schlüsselwort in Ihrem eigenen Code. Es ist konsistent mit den anderen integrierten Typstichwörtern (int, bool, double), und es funktioniert ohne eine using System; Direktive.

Zeichenfolgen sind unveränderlich

Unveränderlich bedeutet, dass der Wert nach dem Erstellen nicht mehr geändert werden kann. Nachdem Sie ein Objekt stringerstellt haben, können Sie dessen Zeichen nicht mehr ändern. Methoden wie ToUpperInvariant, Replace, Substringund Trim geben eine neue Zeichenfolge zurück, die den geänderten Wert enthält. Die ursprüngliche Instanz bleibt gleich.

string greeting = "hello";

// ToUpper returns a *new* string. The original is unchanged.
string shouted = greeting.ToUpperInvariant();

Console.WriteLine(greeting);  // hello
Console.WriteLine(shouted);   // HELLO

Da Zeichenfolgen unveränderlich sind, können Sie sie sicher über Methoden und Threads hinweg freigeben. Diese Unveränderlichkeit erklärt, warum sich der string Typ in der täglichen Verwendung wie ein Werttyp verhält, obwohl es sich um einen Verweistyp handelt.

Wenn Sie in einer Schleife eine Zeichenfolge aus vielen kleinen Teilen erstellen, verwenden Sie StringBuilder, um diese direkt anzufügen und am Ende eine einzige Zeichenfolge zu erzeugen:

// For many sequential edits, StringBuilder avoids allocating a new string each time.
var builder = new StringBuilder();
for (int i = 1; i <= 3; i++)
{
    builder.Append("item ").Append(i).Append(';');
}
string result = builder.ToString();
Console.WriteLine(result);    // item 1;item 2;item 3;

Zeichenfolgenliterale

C# bietet vier Literale Formulare. Jedes Formular passt zu unterschiedlichen Inhalten. Als Kurzanleitung:

  • Verwenden Sie normale Literale für kurzen, einfachen Text mit höchstens wenigen Escapesequenzen.
  • Verwenden Sie Verbatimliterale, wenn Backslashes im Inhalt überwiegen, z. B. bei Windows-Pfaden oder Regex-Mustern.
  • Verwenden Sie Rohzeichenfolgenliterale für mehrzeiligen oder strukturiert formatierten Text, z. B. Inline-JSON, SQL, XML oder formatierte Nachrichtenblöcke.
  • Fügen Sie einem der oben genannten Literale ein $ Präfix hinzu, um eine interpolierte Zeichenfolge abzurufen, wenn Sie Werte einbetten müssen.
  • Fügen Sie einem Literal ein u8 Suffix hinzu, um eine UTF-8-Bytesequenz (a ReadOnlySpan<T> von byte) für byteorientierte APIs zu erzeugen. Ausführliche Informationen finden Sie unter UTF-8-Zeichenfolgenliterale in der Sprachreferenz.

Normale Literale und Escape-Sequenzen

Ein reguläres Zeichenfolgenliteral wird in doppelte Anführungszeichen eingeschlossen. Ein Backslash leitet eine Escape-Sequenz ein:

// Common escape sequences inside a regular string literal.
string tabbed   = "name:\tAda";          // \t  tab
string twoLines = "line 1\nline 2";      // \n  newline
string quoted   = "She said \"hi\".";    // \"  literal quote
string path     = "C:\\src\\app";        // \\  literal backslash

Console.WriteLine(tabbed);
Console.WriteLine(twoLines);
Console.WriteLine(quoted);
Console.WriteLine(path);

Gängige Escape-Sequenzen umfassen \n (Zeilenumbruch), \t (Tabulator), \" (wörtliches Anführungszeichen), \\ (wörtlicher Backslash), \0 (Nullzeichen) und Unicode-Escapes (\uXXXX, \UXXXXXXXX).

Ab C# 13 steht \e für das ESC-Steuerzeichen (U+001B). Es ist das Startbyte für ANSI-Terminal-Escape-Sequenzen:

// Beginning in C# 13, \e represents the ESC control character (U+001B).
// It's used to start ANSI terminal escape sequences.
string esc = "\e[31mError\e[0m: file missing";

Console.WriteLine(esc);                  // ESC[31mError ESC[0m: file missing
Console.WriteLine((int)'\e');          // 27

Verwenden Sie ein gewöhnliches Literal, wenn der Text kurz ist und nur eine Handvoll Escape-Sequenzen enthält. Sobald die Escape-Sequenzen zahlreicher werden als die sichtbaren Zeichen, wechseln Sie zu einem Verbatim-Literal oder einem Raw-Literal.

Verbatim-Literale

Einem Verbatim-Literal wird ein Präfix vorangestellt @. Backslashes werden wörtlich interpretiert, was für Windows-Pfade und Muster für reguläre Ausdrücke nützlich ist:

// A verbatim string literal (@) treats backslashes literally.
// Useful for Windows paths and regular expressions.
string winPath = @"C:\src\app\readme.md";
string pattern = @"\d{3}-\d{4}";

Console.WriteLine(winPath);
Console.WriteLine(pattern);

Um ein Anführungszeichen als Literal in eine Verbatim-Zeichenfolge einzubetten, verdoppeln Sie es: @"She said ""hi"".". Verbatim-Zeichenfolgen können auch mehrere physische Zeilen umfassen.

Verbatim-Literale sind die richtige Wahl, wenn Backslashes Teil des Inhalts sind, aber nicht viele eingebettete Anführungszeichen enthalten sind. Bei mehrteiligem Text oder Inhalt mit Anführungszeichen sind in der Regel unformatierte Zeichenfolgenliterale übersichtlicher.

Unformatierten Zeichenfolgenliterale

Für Literale, die Anführungszeichen, Backslashes oder mehrere Zeilen enthalten, verwenden Sie vorzugsweise Raw-String-Literale. Sie vermeiden escape-Rauschen vollständig, wodurch sie optimal für Inline-JSON-, SQL-, XML-, Regex-Muster und formatierte Textblöcke geeignet sind, in denen die Quelle wie die Ausgabe aussehen soll:

// Raw string literals use three or more quotes and need no escaping.
// The source looks like the output, which is ideal for inline JSON, SQL, XML, and the like.
string json = """
    {
        "name": "Ada",
        "roles": ["admin", "editor"]
    }
    """;

string sql = """
    SELECT Id, Name
    FROM   Users
    WHERE  Name = 'O''Brien'
    """;

Console.WriteLine(json);
Console.WriteLine(sql);

Rohzeichenfolgenliterale machen Escape-Sequenzen nahezu überflüssig und ermöglichen jede benötigte Formatierung und Verwendung von Anführungszeichen. Die vollständigen Regeln finden Sie unter Rohzeichenfolgenliterale.

Interpolierte Zeichenfolgen

Ein $ Präfix wandelt ein Literal in eine interpolierte Zeichenfolge um. Ausdrücke in {} Löchern werden ausgewertet und deren Ergebnisse eingefügt, und Sie können Standardformatbezeichner und Ausrichtung innerhalb der Löcher anwenden. Interpolation lässt sich auch mit den anderen Literalformen kombinieren – verwenden Sie $@"...", um ein wortwörtliches Literal zu interpolieren, oder $"""...""", um ein Rohzeichenfolgenliteral für eine umfangreich formatierte Ausgabe zu interpolieren:

// The $ prefix evaluates expressions inside { } and inserts their values.
string name = "Ada";
int score = 92;

string greeting = $"Hello, {name}! Your score is {score}.";
// Format specifiers and alignment work inside the holes.
string formatted = $"pi = {Math.PI:F3}, padded = |{name,10}|";

// Combine $ and """ for richly formatted multiline output.
string report = $"""
    Report for {name}
    -----------------
    Score : {score}
    Grade : {(score >= 90 ? "A" : "B")}
    """;

Console.WriteLine(greeting);
Console.WriteLine(formatted);
Console.WriteLine(report);

Interpolation ist die empfohlene Methode zum Verfassen von Zeichenfolgen aus Werten im alltäglichen Code.

Indizierung und char

A string ist eine Sequenz von UTF-16-Codeeinheiten. Der Indexer gibt eine System.Charzurück, die eine einzelne UTF-16-Codeeinheit darstellt, nicht unbedingt einen vollständigen Unicode-Codepunkt. Length gibt die Anzahl der Codeeinheiten zurück.

// A string is a sequence of UTF-16 code units. s[i] returns one char.
string word = "café";

Console.WriteLine(word.Length);          // 4
Console.WriteLine(word[0]);              // c

foreach (char c in word)
{
    Console.Write($"{c} ");              // c a f é
}
Console.WriteLine();

Für Text, der Emojis oder Zeichen außerhalb der Basic Multilingual Plane enthalten kann, iterieren Sie mithilfe von Rune nach Rune oder mithilfe von StringInfo nach Graphemclustern. Eine einfache char-Iteration funktioniert für die meisten westlichen Texte und ASCII-dominierten Inhalte.

String-Gleichheit

Gleichheit bei string vergleicht die Zeichenfolgen, nicht Verweise:

// String equality compares character sequences, not references.
string left  = "hello";
string right = string.Concat("hel", "lo");

Console.WriteLine(left == right);                                      // True
Console.WriteLine(left.Equals(right, StringComparison.Ordinal));       // True

Für Vergleiche, die gebietsschemafähig oder fallfähig sein müssen, übergeben Sie einen expliziten StringComparison Wert. Verwenden Sie StringComparison.Ordinal für Protokollwerte, Bezeichner und anderen nichtsprachlichen Text.

Häufige Operationen mit Zeichenfolgen

Verwenden Sie die folgende Tabelle als Kurzanleitung für alltägliche Zeichenfolgenvorgänge in C#:

Category Was es abdeckt
Search Suchen nach Zeichen oder Teilzeichenfolgen, Testpräfixen und Suffixen
Split Eine Zeichenfolge anhand von Trennzeichen in Teilzeichenfolgen aufteilen
Verketten Kombinieren von Zeichenfolgen — +, Interpolation, Concat, Join
Modify Erstellen einer transformierten Kopie — Replace, , TrimSubstring
Vergleichen Gleichheit und Reihenfolge mit dem richtigen StringComparison prüfen

Die vollständige API-Oberfläche – jede Überladung, jede Methode – wird in der String Referenz dokumentiert.

Siehe auch

  • Last updated on