Zeichenfolgen
Aktualisiert: November 2007
Eine C#-Zeichenfolge ist eine Gruppe von einem oder mehr Zeichen, die mit dem string-Schlüsselwort deklariert werden, das in C# eine Kurzform für die System.String-Klasse ist. Die Verwendung von Zeichenfolgen in C# ist im Vergleich zu Zeichenarrays in C oder C++ wesentlicher einfacher und deutlich weniger fehleranfällig.
Ein Zeichenfolgenliteral wird mit Anführungszeichen deklariert, wie im folgenden Beispiel gezeigt:
string greeting = "Hello, World!";
Sie können, wie nachfolgend gezeigt, Teilzeichenfolgen extrahieren und Zeichenfolgen verketten:
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.
Zeichenfolgenobjekte sind insofern unveränderlich, als dass sie nach der Erstellung nicht mehr geändert werden können. Methoden, die auf Zeichenfolgen angewendet werden, geben eigentlich neue Zeichenfolgenobjekte zurück. Deshalb sollten aus Leistungsgründen umfangreiche Verkettungen oder andere Manipulationen von Zeichenfolgen mithilfe der StringBuilder-Klasse durchgeführt werden, wie folgende Codebeispiele zeigen.
Verwenden von Zeichenfolgen
Escapezeichen
Escapezeichen wie "\n" (neue Zeile) und "\t" (Registerkarte) können in Zeichenfolgen eingeschlossen werden. Die Zeile:
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
ist das Gleiche wie:
Hello
World!
Wenn Sie einen umgekehrten Schrägstrich einbeziehen möchten, muss diesem ein weiterer umgekehrter Schrägstrich vorangestellt werden. Die folgende Zeichenfolge:
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."
ist exakt das Gleiche wie:
\\My Documents\
Das @-Symbol
Das Symbol @ gibt an, dass Escapezeichen und Zeilenumbrüche beim Erstellen der Zeichenfolge ignoriert werden sollen. Die beiden folgenden Zeichenfolgen sind deshalb identisch:
string p1 = "\\\\My Documents\\My Files\\";
string p2 = @"\\My Documents\My Files\";
ToString()
Alle in C# integrierten Datentypen stellen die ToString-Methode bereit, die einen Wert in eine Zeichenfolge umwandelt. Diese Methode kann verwendet werden, um numerische Werte in Zeichenfolgen zu konvertieren, z. B. hier:
int year = 1999;
string msg = "Eve was born in " + year.ToString();
System.Console.WriteLine(msg); // outputs "Eve was born in 1999"
Zugreifen auf einzelne Zeichen
Auf einzelne Zeichen in einer Zeichenfolge kann mit verschiedenen Methoden zugegriffen werden, z. B. Substring, Replace, Split und Trim.
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
Es ist auch möglich, die Zeichen in ein Zeichenarray zu kopieren, z. B.:
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?
Auf einzelne Zeichen einer Zeichenfolge kann mit einem Index zugegriffen werden, z. B.:
string s5 = "Printing backwards";
for (int i = 0; i < s5.Length; i++)
{
System.Console.Write(s5[s5.Length - i - 1]);
}
// Output: "sdrawkcab gnitnirP"
Ändern der Groß-/Kleinschreibung
Zur Änderung der Groß- oder Kleinschreibung von Buchstaben in einer Zeichenfolge verwenden Sie ToUpper() bzw. ToLower(), z. B.:
string s6 = "Battle of Hastings, 1066";
System.Console.WriteLine(s6.ToUpper());
// outputs "BATTLE OF HASTINGS 1066"
System.Console.WriteLine(s6.ToLower());
// outputs "battle of hastings 1066"
Vergleiche
Am einfachsten lassen sich zwei nicht lokalisierte Zeichenfolgen mit der Equals-Methode mit StringComparison.Ordinal und StringComparison.OrdinalIgnoreCase vergleichen.
// Internal strings that will never be localized.
string root = @"C:\users";
string root2 = @"C:\Users";
// Use the overload of the Equals method that specifies a StringComparison.
// Ordinal is the fastest way to compare two strings.
bool result = root.Equals(root2, StringComparison.Ordinal);
Console.WriteLine("Ordinal comparison: {0} and {1} are {2}", root, root2,
result ? "equal." : "not equal.");
// To ignore case means "user" equals "User". This is the same as using
// String.ToUpperInvariant on each string and then performing an ordinal comparison.
result = root.Equals(root2, StringComparison.OrdinalIgnoreCase);
Console.WriteLine("Ordinal ignore case: {0} and {1} are {2}", root, root2,
result ? "equal." : "not equal.");
// A static method is also available.
bool areEqual = String.Equals(root, root2, StringComparison.Ordinal);
// String interning. Are these really two distinct objects?
string a = "The computer ate my source code.";
string b = "The computer ate my source code.";
// ReferenceEquals returns true if both objects
// point to the same location in memory.
if (String.ReferenceEquals(a, b))
Console.WriteLine("a and b are interned.");
else
Console.WriteLine("a and b are not interned.");
// Use String.Copy method to avoid interning.
string c = String.Copy(a);
if (String.ReferenceEquals(a, c))
Console.WriteLine("a and c are interned.");
else
Console.WriteLine("a and c are not interned.");
Zeichenfolgenobjekte verfügen außerdem über eine CompareTo()-Methode, die einen Ganzzahlwert zurückgibt, der angibt, ob eine Zeichenfolge kleiner (<) oder größer (>) ist als eine andere. Beim Vergleichen von Zeichenfolgen wird der Unicode-Wert verwendet, sodass Kleinbuchstaben einen niedrigeren Wert haben als Großbuchstaben.
// Enter different values for string1 and string2 to
// experiement with behavior of CompareTo
string string1 = "ABC";
string string2 = "abc";
int result2 = string1.CompareTo(string2);
if (result2 > 0)
{
System.Console.WriteLine("{0} is greater than {1}", string1, string2);
}
else if (result2 == 0)
{
System.Console.WriteLine("{0} is equal to {1}", string1, string2);
}
else if (result2 < 0)
{
System.Console.WriteLine("{0} is less than {1}", string1, string2);
}
// Output: ABC is less than abc
Zum Suchen einer Zeichenfolge innerhalb einer anderen Zeichenfolge verwenden Sie IndexOf(). IndexOf() gibt -1 zurück, wenn die Zeichenfolge nicht gefunden wurde. Andernfalls wird der Index (Basis 0) der ersten Fundstelle zurückgegeben.
// Date strings are interpreted according to the current culture.
// If the culture is en-US, this is interpreted as "January 8, 2008",
// but if the user's computer is fr-FR, this is interpreted as "August 1, 2008"
string date = "01/08/2008";
DateTime dt = Convert.ToDateTime(date);
Console.WriteLine("Year: {0}, Month: {1}, Day: {2}", dt.Year, dt.Month, dt.Day);
// Specify exactly how to interpret the string.
IFormatProvider culture = new System.Globalization.CultureInfo("fr-FR", true);
// Alternate choice: If the string has been input by an end user, you might
// want to format it according to the current culture:
// IFormatProvider culture = System.Threading.Thread.CurrentThread.CurrentCulture;
DateTime dt2 = DateTime.Parse(date, culture, System.Globalization.DateTimeStyles.AssumeLocal);
Console.WriteLine("Year: {0}, Month: {1}, Day {2}", dt2.Year, dt2.Month, dt2.Day);
/* Output (assuming first culture is en-US and second is fr-FR):
Year: 2008, Month: 1, Day: 8
Year: 2008, Month: 8, Day 1
*/
Teilen einer Zeichenfolge in Teilzeichenfolgen
Das Teilen einer Zeichenfolge in Teilzeichenfolgen, z. B. das Teilen eines Satzes in seine einzelnen Wörter, ist eine häufig vorkommende Programmieraufgabe. Die Split()-Methode erhält ein char-Array von Trennzeichen (z. B. ein Leerzeichen) und gibt ein Array von Teilzeichenfolgen zurück. Sie können auf dieses Array mit foreach zugreifen, z. B.:
string numString = "1287543"; //"1287543.0" will return false for a long
long number1 = 0;
bool canConvert = long.TryParse(numString, out number1);
if (canConvert == true)
Console.WriteLine("number1 now = {0}", number1);
else
Console.WriteLine("numString is not a valid long");
byte number2 = 0;
numString = "255"; // A value of 256 will return false
canConvert = byte.TryParse(numString, out number2);
if (canConvert == true)
Console.WriteLine("number2 now = {0}", number2);
else
Console.WriteLine("numString is not a valid byte");
decimal number3 = 0;
numString = "27.3"; //"27" is also a valid decimal
canConvert = decimal.TryParse(numString, out number3);
if (canConvert == true)
Console.WriteLine("number3 now = {0}", number3);
else
Console.WriteLine("number3 is not a valid decimal");
Dieser Code gibt jedes Wort auf einer separaten Zeile aus, z. B.:
The
cat
sat
on
the
mat.
Verwenden von StringBuilder
Die StringBuilder-Klasse erstellt einen Zeichenfolgenpuffer, der eine verbesserte Leistung bietet, falls in Ihrem Programm viele Bearbeitungsvorgänge von Zeichenfolgen durchgeführt werden. Mit der StringBuilder-Klasse können auch einzelne Zeichen neu zugewiesen werden. Dieser Vorgang wird vom integrierten Zeichenfolgen-Datentyp nicht unterstützt.
In diesem Beispiel wird ein StringBuilder-Objekt erstellt, dem der Inhalt mithilfe der Append-Methode schrittweise hinzugefügt wird.
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
}
}
Siehe auch
Aufgaben
Gewusst wie: Generieren von mehrzeiligen Zeichenfolgenliteralen (Visual C#)
Gewusst wie: Suchen nach einer Zeichenfolge in einem Zeichenfolgenarray
Gewusst wie: Suchen innerhalb einer Zeichenfolge
Konzepte
Integrierte Datentypen (Visual C# Express)