Grundlagen zu Zeichenfolgen (C#-Programmierhandbuch)
Aktualisiert: November 2007
Eine Zeichenfolge ist ein Objekt vom Typ String, dessen Wert Text ist. Intern wird der Text als schreibgeschützte Auflistung von Char-Objekten gespeichert, von denen jedes ein in UTF-16 codiertes Unicode-Zeichen darstellt. Eine C#-Zeichenfolge wird nicht mit einem NULL-Zeichen am Ende terminiert (im Gegensatz zu C und C++). Deshalb kann eine C#-Zeichenfolge eine beliebige Anzahl eingebetteter NULL-Zeichen ('\0') enthalten. Die Länge einer Zeichenfolge stellt die Anzahl der Zeichen unabhängig davon dar, ob die Zeichen aus Unicode-Ersatzzeichenpaaren gebildet werden oder nicht. Um in einer Zeichenfolge auf die einzelnen Unicode-Codepunkte zuzugreifen, verwenden Sie das StringInfo-Objekt.
Zeichenfolge im Vergleich zu System.String
In C# ist das string-Schlüsselwort ein Alias für String. Deshalb entsprechen sich String und string, und Sie können eine beliebige Namenskonvention verwenden. Die String-Klasse stellt viele Methoden zum sicheren Erstellen, Bearbeiten und Vergleichen von Zeichenfolgen bereit. Außerdem überlädt die Programmiersprache C# einige Operatoren, um allgemeine Zeichenfolgenoperationen zu vereinfachen. Weitere Informationen über das Schlüsselwort finden Sie unter string (C#-Referenz). Weitere Informationen über den Typ und seine Methoden finden Sie unter String.
Deklarieren und Initialisieren von Zeichenfolgen
Sie haben verschiedene Möglichkeiten, Zeichenfolgen zu initialisieren und zu deklarieren, wie im folgenden Beispiel dargestellt:
// 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 den new-Operator nur dann zum Erstellen eines Zeichenfolgenobjekts verwenden, wenn Sie die Zeichenfolge mit einem Zeichenarray initialisieren.
Initialisieren Sie eine Zeichenfolge mit dem konstanten Empty-Wert, um ein neues String-Objekt zu erstellen, dessen Zeichenfolge die Länge NULL aufweist. Die Zeichenfolgenliteraldarstellung einer Zeichenfolge der Länge 0 (null) ist "". Durch die Initialisierung von Zeichenfolgen mit dem Wert Empty anstelle von null können Sie die Chancen einer NullReferenceException reduzieren. Verwenden Sie die statische IsNullOrEmpty(String)-Methode, um den Wert einer Zeichenfolge zu prüfen, bevor Sie versuchen, darauf zuzugreifen.
Unveränderlichkeit von Zeichenfolgenobjekten
Zeichenfolgenobjekte sind unveränderlich. Das bedeutet, dass sie nicht mehr geändert werden können, nachdem sie erstellt wurden. Alle String-Methoden und C#-Operatoren, mit denen eine Zeichenfolge geändert werden könnte, geben diese Ergebnisse in einem neuen Zeichenfolgenobjekt zurück. Im folgenden Beispiel bleiben beim Verketten des Inhalts von s1 und s2 zu einer einzelnen Zeichenfolge die beiden ursprünglichen Zeichenfolgen unverändert. Der Operator += erstellt eine neue Zeichenfolge, die die kombinierten Inhalte enthält. Dieses neue Objekt wird der Variablen s1 zugewiesen. 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" einer neuen Zeichenfolgenerstellung gleichkommt, müssen Sie beim Erstellen von Verweisen auf Zeichenfolgen vorsichtig sein. Wenn Sie einen Verweis auf eine Zeichenfolge erstellen und dann die ursprüngliche Zeichenfolge ändern, zeigt der Verweis weiterhin auf das ursprüngliche Objekt und nicht auf das neue Objekt, das beim Ändern der Zeichenfolge erstellt wurde. Der folgende Code veranschaulicht dieses Verhalten:
string s1 = "Hello ";
string s2 = s1;
s1 += "World";
System.Console.WriteLine(s2);
//Output: Hello
Weitere Informationen zum Erstellen neuer Zeichenfolgen, die auf Änderungen wie Such- und Ersetzungsvorgängen basieren, finden Sie unter Gewusst wie: Ändern von Zeichenfolgeninhalten (C#-Programmierhandbuch).
Reguläre und wörtliche Zeichenfolgenliterale
Verwenden Sie reguläre Zeichenfolgenliterale, wenn Sie Escapezeichen in C#, wie im folgenden Beispiel dargestellt, einbetten müssen:
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
Verwenden Sie wörtliche Zeichenfolgen zur bequemeren Verwendung und besseren Lesbarkeit, wenn der Zeichenfolgentext umgekehrte Schrägstriche, z. B. in Dateipfaden, enthält. Da wörtliche Zeichenfolgen neue Zeilenzeichen als Teil des Zeichenfolgentexts beibehalten, können sie zum Initialisieren mehrzeiliger Zeichenfolgen verwendet werden. Verwenden Sie doppelte Anführungszeichen, um ein Anführungszeichen in eine wörtliche Zeichenfolge einzubetten. Im folgenden Beispiel werden einige häufige Anwendungen für wörtliche Zeichenfolgen dargestellt:
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."
Zeichenfolgen-Escapesequenzen
Escapesequenz |
Zeichenname |
Unicode-Codierung |
|---|---|---|
\' |
Einfaches Anführungszeichen |
0x0027 |
\" |
Doppeltes Anführungszeichen |
0x0022 |
\\ |
Umgekehrter Schrägstrich |
0x005C |
\0 |
Null |
0x0000 |
\a |
Warnung |
0x0007 |
\b |
Rückschritt |
0x0008 |
\f |
Seitenvorschub |
0x000C |
\n |
Zeilenwechsel |
0x000A |
\r |
Wagenrücklauf |
0x000D |
\t |
Horizontaler Tabulator |
0x0009 |
\U |
Unicode-Escapesequenz für Ersatzzeichenpaare. |
\Unnnnnnnn |
\u |
Unicode-Escapesequenzen |
\u0041 = "A" |
\v |
Vertikaler Tabulator |
0x000B |
\x |
Unicode-Escape-Folge ähnlich wie "\u" außer mit variabler Länge. |
\x0041 = "A" |
.gif "Hinweis") Hinweis: |
|---|
Wörtliche Zeichenfolgen werden zur Kompilierzeit in normale Zeichenfolgen mit gleichen Escapesequenzen umgewandelt. Wenn Sie also eine wörtliche Zeichenfolge im Debugger-Überwachungsfenster anzeigen, werden die Escape-Zeichen angezeigt, die vom Compiler hinzugefügt wurden und nicht die wörtliche Version aus dem Quellcode. Zum Beispiel die wörtliche Zeichenfolge @ "C:\files.txt" wird im Überwachungsfenster als "C:\\files.txt" angezeigt. |
Formatzeichenfolgen
Eine Formatzeichenfolge ist eine Zeichenfolge, deren Inhalt zur Laufzeit dynamisch bestimmt werden kann. Sie erstellen ein Format, indem Sie die statische Format-Methode verwenden und Platzhalter in geschweiften Klammern einbetten, die durch andere Werte zur Laufzeit ersetzt werden. Im folgenden Beispiel wird eine Formatzeichenfolge verwendet, um das Ergebnis jeder Iteration einer Schleife auszugeben:
class FormatString
{
static void Main()
{
// Get user input.
System.Console.WriteLine("Enter a number");
string input = System.Console.ReadLine();
// Convert the input string to an int.
int j;
System.Int32.TryParse(input, out j);
// Write a different string each iteration.
string s;
for (int i = 0; i < 10; i++)
{
// A simple format string with no alignment formatting.
s = System.String.Format("{0} times {1} = {2}", i, j, (i * j));
System.Console.WriteLine(s);
}
//Keep the console window open in debug mode.
System.Console.ReadKey();
}
}
Eine Überladung der WriteLine-Methode übernimmt eine Formatzeichenfolge als Parameter. Deshalb können Sie nur ein Formatzeichenfolgenliteral ohne einen expliziten Aufruf der Methode einbetten. Wenn Sie jedoch die WriteLine-Methode zum Anzeigen der Debugausgabe im Ausgabefenster von Visual Studio verwenden, müssen Sie die Format-Methode ausdrücklich aufrufen, da WriteLine nur eine Zeichenfolge akzeptiert, aber keine Formatzeichenfolge. Weitere Informationen zu Formatzeichenfolgen finden Sie unter Formatierung von Typen.
Teilzeichenfolgen
Eine Teilzeichenfolge ist jede Sequenz von Zeichen, die in einer Zeichenfolge enthalten sind. Verwenden Sie die Substring-Methode, um eine neue Zeichenfolge aus einem Teil der ursprünglichen Zeichenfolge zu erstellen. Sie können nach einem oder mehreren Vorkommen einer Teilzeichenfolge mit der IndexOf-Methode suchen. Verwenden Sie die Replace-Methode, um alle Vorkommen einer angegebenen Teilzeichenfolge durch eine neue Zeichenfolge zu ersetzen. Wie die Substring-Methode gibt Replace eine neue Zeichenfolge zurück und ändert die ursprüngliche Zeichenfolge nicht. Weitere Informationen finden Sie unter Gewusst wie: Suchen von Zeichenfolgen mithilfe von Zeichenfolgenmethoden (C#-Programmierhandbuch) und unter Gewusst wie: Ändern von Zeichenfolgeninhalten (C#-Programmierhandbuch).
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, wie im folgenden Beispiel dargestellt:
string s5 = "Printing backwards";
for (int i = 0; i < s5.Length; i++)
{
System.Console.Write(s5[s5.Length - i - 1]);
}
// Output: "sdrawkcab gnitnirP"
Falls die String-Methoden nicht die Funktionen bieten, die Sie zum Ändern einzelner Zeichen in einer Zeichenfolge benötigen, können Sie ein StringBuilder-Objekt zum direkten Ändern einzelner Zeichen verwenden und dann eine neue Zeichenfolge zum Speichern der Ergebnisse mithilfe der StringBuilder-Methoden erstellen. Im folgenden Beispiel wird davon ausgegangen, dass Sie die ursprüngliche Zeichenfolge auf bestimmte Weise ändern müssen und die Ergebnisse dann für eine spätere Verwendung speichern:
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?
NULL-Zeichenfolgen und leere Zeichenfolgen
Eine leere Zeichenfolge ist eine Instanz eines System.String-Objekts, die 0 (null) Zeichen enthält. Leere Zeichenfolgen werden häufig in verschiedenen Programmierszenarios verwendet, um ein leeres Textfeld darzustellen. Sie können Methoden für leere Zeichenfolgen aufrufen, da sie gültige System.String-Objekte sind. Leere Zeichenfolgen werden wie folgt initialisiert:
string s = String.Empty;
Eine NULL-Zeichenfolge bezieht sich hingegen nicht auf eine Instanz eines System.String-Objekts, und jeder Versuch, eine Methode für eine NULL-Zeichenfolge aufzurufen, führt zu einer NullReferenceException. NULL-Zeichenfolgen können jedoch in Verkettungs- und Vergleichsvorgängen mit anderen Zeichenfolgen verwendet werden. Die folgenden Beispiele zeigen, wann ein Verweis auf eine NULL-Zeichenfolge zu einer Ausnahme führt und wann nicht:
static void Main()
{
string str = "hello";
string nullStr = null;
string emptyStr = "a";
string tempStr = str + nullStr; // tempStr = "hello"
bool b = (emptyStr == nullStr);// b = false;
string newStr = emptyStr + nullStr; // creates a new empty string
int len = nullStr.Length; // throws NullReferenceException
}
Verwenden von StringBuilder zur schnellen Zeichenfolgenerstellung
Zeichenfolgenoperationen in .NET sind in höchstem Maße optimiert und wirken sich nicht wesentlich auf die Leistung aus. In einigen Szenarios, wie geschlossenen Schleifen, die Hunderte oder Tausende Male ausgeführt werden, können sich die Zeichenfolgenoperationen auf die Leistung auswirken. Die StringBuilder-Klasse erstellt einen Zeichenfolgenpuffer, der eine verbesserte Leistung gewährleistet, falls Zeichenfolgen in Ihrem Programm häufig geändert werden. Mit der StringBuilder-Zeichenfolge können auch einzelne Zeichen neu zugewiesen werden, was vom integrierten Datentyp für Zeichenfolgen nicht unterstützt wird. Dieser Code ändert zum Beispiel 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());
System.Console.ReadLine();
//Outputs Cat: the ideal pet
In diesem Beispiel wird ein StringBuilder-Objekt verwendet, um eine Zeichenfolge aus einer Reihe von numerischen Typen zu erstellen:
class TestStringBuilder
{
static void Main()
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
// Create a string composed of numbers 0 - 9
for (int i = 0; i < 10; i++)
{
sb.Append(i.ToString());
}
System.Console.WriteLine(sb); // displays 0123456789
// Copy one character of the string (not possible with a System.String)
sb[0] = sb[9];
System.Console.WriteLine(sb); // displays 9123456789
}
}
Zeichenfolgen, Erweiterungsmethoden und LINQ
Da der String-Typ IEnumerable<T> implementiert, können Sie die in der Enumerable-Klasse in Zeichenfolgen definierten Erweiterungsmethoden verwenden. Aus Gründen der Übersichtlichkeit werden diese Methoden für den String-Typ aus IntelliSense ausgeschlossen, sie sind jedoch weiterhin vorhanden. Sie können auch LINQ-Abfrageausdrücke für Zeichenfolgen verwenden. Weitere Informationen hierzu finden Sie unter LINQ und Zeichenfolgen.
Siehe auch
Aufgaben
Gewusst wie: Suchen von Zeichenfolgen mithilfe von regulären Ausdrücken (C#-Programmierhandbuch)
Gewusst wie: Suchen von Zeichenfolgen mithilfe von Zeichenfolgenmethoden (C#-Programmierhandbuch)
Gewusst wie: Aufteilen von Zeichenfolgen (C#-Programmierhandbuch)