Vorgehensweise: Verketten mehrerer Zeichenfolgen (C#-Handbuch)
Verkettung ist der Prozess, eine Zeichenfolge ans Ende einer anderen Zeichenfolge anzufügen. Sie können Zeichenfolgen mithilfe des +-Operators verketten. Bei Zeichenfolgenliteralen und Zeichenfolgenkonstanten erfolgt die Verkettung beim Kompilieren. Es erfolgt keine Verkettung zur Laufzeit. Bei Zeichenfolgenvariablen erfolgt die Verkettung nur zur Laufzeit.
Hinweis
Die C#-Beispiele in diesem Artikel werden in der Inlinecodeausführung und dem Playground von Try.NET ausgeführt. Klicken Sie auf die Schaltfläche Ausführen, um ein Beispiel in einem interaktiven Fenster auszuführen. Nachdem Sie den Code ausgeführt haben, können Sie ihn ändern und den geänderten Code durch erneutes Anklicken der Schaltfläche Ausführen ausführen. Der geänderte Code wird entweder im interaktiven Fenster ausgeführt, oder das interaktive Fenster zeigt alle C#-Compilerfehlermeldungen an, wenn die Kompilierung fehlschlägt.
Zeichenfolgenliterale
Im folgenden Beispiel wird ein langes Zeichenfolgenliteral in kleinere Zeichenfolgen aufgeteilt, um die Lesbarkeit im Quellcode zu verbessern. Der Code verkettet die kleineren Zeichenfolgen, um das lange Zeichenfolgenliteral zu erstellen. Die Teile werden zur Kompilierzeit zu einer einzelnen Zeichenfolge verkettet. Es entstehen unabhängig von der Anzahl an Zeichenfolgen keine Leistungseinbußen zur Laufzeit.
// Concatenation of literals is performed at compile time, not run time.
string text = "Historically, the world of data and the world of objects " +
"have not been well integrated. Programmers work in C# or Visual Basic " +
"and also in SQL or XQuery. On the one side are concepts such as classes, " +
"objects, fields, inheritance, and .NET Framework APIs. On the other side " +
"are tables, columns, rows, nodes, and separate languages for dealing with " +
"them. Data types often require translation between the two worlds; there are " +
"different standard functions. Because the object world has no notion of query, a " +
"query can only be represented as a string without compile-time type checking or " +
"IntelliSense support in the IDE. Transferring data from SQL tables or XML trees to " +
"objects in memory is often tedious and error-prone.";
System.Console.WriteLine(text);
Die Operatoren + und +=
Zum Verketten von Zeichenfolgenvariablen können Sie die Operatoren + und +=, die Zeichenfolgeninterpolation oder die Methoden String.Format, String.Concat, String.Join oder StringBuilder.Append verwenden. Der Operator + ist einfach zu verwenden und gut für intuitiv verständlichen Code geeignet. Auch wenn Sie mehrere +-Operatoren in einer Anweisung verwenden, wird der Inhalt der Zeichenfolge nur einmal kopiert. Der folgende Code zeigt Beispiele für die Verwendung der Operatoren + und += zum Verketten von Zeichenfolgen:
string userName = "<Type your name here>";
string dateString = DateTime.Today.ToShortDateString();
// Use the + and += operators for one-time concatenations.
string str = "Hello " + userName + ". Today is " + dateString + ".";
System.Console.WriteLine(str);
str += " How are you today?";
System.Console.WriteLine(str);
Zeichenfolgeninterpolierung
In einigen Ausdrücken ist es einfacher, Zeichenfolgen mithilfe der Zeichenfolgeninterpolation zu verketten, wie in folgendem Beispiel gezeigt wird:
string userName = "<Type your name here>";
string date = DateTime.Today.ToShortDateString();
// Use string interpolation to concatenate strings.
string str = $"Hello {userName}. Today is {date}.";
System.Console.WriteLine(str);
str = $"{str} How are you today?";
System.Console.WriteLine(str);
Hinweis
Bei der Zeichenfolgenverkettung behandelt der C#-Compiler eine NULL-Zeichenfolge wie eine leere Zeichenfolge.
Ab C# 10 können Sie die Zeichenfolgeninterpolation verwenden, um eine konstante Zeichenfolge zu initialisieren, wenn alle für Platzhalter verwendeten Ausdrücke auch konstante Zeichenfolgen sind.
String.Format
Eine andere Methoden zum Verketten von Zeichenfolgen ist String.Format. Diese Methode funktioniert gut, wenn Sie eine Zeichenfolge mit einer kleinen Anzahl von Zeichenfolgenkomponenten erstellen.
StringBuilder
In anderen Fällen kann es passieren, dass Sie Zeichenfolgen in einer Schleife kombinieren, bei der Sie nicht wissen, wie viele Quellzeichenfolgen kombiniert werden, und die tatsächliche Anzahl an Quellzeichenfolgen kann in solchen Fällen sehr groß sein. Für solche Szenarios wurde die Klasse StringBuilder entwickelt. Im folgenden Code werden Zeichenfolgen mit der Methode Append der Klasse StringBuilder verkettet.
// Use StringBuilder for concatenation in tight loops.
var sb = new System.Text.StringBuilder();
for (int i = 0; i < 20; i++)
{
sb.AppendLine(i.ToString());
}
System.Console.WriteLine(sb.ToString());
Erfahren Sie mehr über die Gründe für das Verketten von Zeichenfolgen oder die StringBuilder-Klasse.
String.Concat oder String.Join
Eine weitere Option zum Verketten von Zeichenfolgen aus einer Sammlung ist die Verwendung der Methode String.Concat. Verwenden Sie String.Join-Methode, wenn ein Trennzeichen Quellzeichenfolgen trennen soll. Der folgenden Code kombiniert ein Array aus Wörtern mithilfe beider Methoden:
string[] words = { "The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog." };
var unreadablePhrase = string.Concat(words);
System.Console.WriteLine(unreadablePhrase);
var readablePhrase = string.Join(" ", words);
System.Console.WriteLine(readablePhrase);
LINQ und Enumerable.Aggregate
Die letzte Option zum Verketten von Zeichenfolgen aus einer Sammlung ist die Verwendung von LINQ und der Methode Enumerable.Aggregate. Diese Methode kombiniert die Quellzeichenfolgen mithilfe eines Lambdaausdrucks. Der Lambdaausdruck fügt jede Zeichenfolge der vorhandenen Akkumulation zu. Im folgenden Beispiel wird ein Array von Worten kombiniert, indem zwischen jedem Wort im Array Leerzeichen hinzugefügt werden:
string[] words = { "The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog." };
var phrase = words.Aggregate((partialPhrase, word) =>$"{partialPhrase} {word}");
System.Console.WriteLine(phrase);
Diese Option kann mehr Zuordnungen verursachen als andere Methoden zum Verketten von Auflistungen, da sie eine Zwischenzeichenfolge für jede Iteration erstellt. Wenn die Optimierung der Leistung entscheidend ist, sollten Sie die StringBuilder-Klasse bzw. die String.Concat- oder String.Join-Methode in Betracht ziehen, um eine Auflistung zu verketten (anstelle von Enumerable.Aggregate).
