(0) exportieren Drucken
Alle erweitern

Verwenden von Zeichenfolgen (C#-Programmierhandbuch)

Eine C#-Zeichenfolge ist ein Zeichenarray, das mit dem string-Schlüsselwort deklariert wird. Ein Zeichenfolgenliteral wird mit Anführungszeichen deklariert, wie im folgenden Beispiel gezeigt:

string s = "Hello, World!";

Sie können, wie nachfolgend gezeigt, Teilzeichenfolgen extrahieren und Zeichenfolgen verketten:

string s1 = "orange";
string s2 = "red";

s1 += s2;
System.Console.WriteLine(s1);  // outputs "orangered"

s1 = s1.Substring(2, 5);
System.Console.WriteLine(s1);  // outputs "anger"

Zeichenfolgenobjekte sind unveränderlich. Das bedeutet, dass sie nicht mehr geändert werden können, nachdem sie erstellt wurden. Methoden, die auf Zeichenfolgen angewendet werden, geben eigentlich neue Zeichenfolgenobjekte zurück. Wenn nun, bezogen auf das vorherige Beispiel, die Inhalte von s1 und s2 zu einer einzigen Zeichenfolge verkettet werden, bleiben die zwei Zeichenfolgen mit dem Inhalt "orange" und "red" beide unverändert. Der +=-Operator erstellt eine neue Zeichenfolge, die die kombinierten Inhalte enthält. Infolgedessen verweist s1 nun gänzlich auf eine andere Zeichenfolge. Eine Zeichenfolge, die nur "orange" enthält, ist zwar immer noch vorhanden, auf diese wird aber nicht mehr verwiesen, sobald s1 verkettet wurde.

NoteHinweis

Beim Erstellen von Verweisen auf Zeichenfolgen ist Vorsicht angebracht. Wenn Sie einen Verweis auf eine Zeichenfolge erstellen und dann die Zeichenfolge ändern, zeigt der Verweis weiterhin auf das ursprüngliche Objekt und nicht auf das neue Objekt, das beim Ändern der Zeichenfolge erstellt wurde. Diese Gefahr wird anhand des folgenden Codes veranschaulicht:

string s1 = "Hello";
string s2 = s1;
s1 += " and goodbye.";
Console.WriteLine(s2); //outputs "Hello"

Da beim Ändern von Zeichenfolgen neue Zeichenfolgenobjekte erstellt werden, sollten aus Leistungsgründen umfangreiche Verkettungen oder sonstige Zeichenfolgenbearbeitungen mit der StringBuilder-Klasse ausgeführt werden, wie im folgenden Beispiel:

System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.Append("one ");
sb.Append("two ");
sb.Append("three");
string str = sb.ToString();

Die StringBuilder-Klasse wird weiter unten im Abschnitt "Verwenden von StringBuilder" ausführlicher behandelt.

Verwenden von Zeichenfolgen

Escapezeichen

Escapezeichen wie "\n" (neue Zeile) und "\t" (Registerkarte) können in Zeichenfolgen eingeschlossen werden. Die Zeile:

string hello = "Hello\nWorld!";

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 = "\\\\My Documents\\";

ist exakt das Gleiche wie:

\\My Documents\

Das @-Symbol

Das @-Symbol weist den Zeichenfolgenkonstruktor an, Escapezeichen und Zeilenumbrüche zu ignorieren. Die beiden folgenden Zeichenfolgen sind deshalb identisch:

string p1 = "\\\\My Documents\\My Files\\";
string p2 = @"\\My Documents\My Files\";

ToString()

So wie alle Objekte, die von Object abgeleitet sind, stellen Zeichenfolgen die ToString-Methode bereit, die einen Wert in eine Zeichenfolge konvertiert. 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 folgenden Methoden zugegriffen werden, z. B. SubString(), Replace(),, Split() und Trim().

string s3 = "Visual C# Express";

System.Console.WriteLine(s3.Substring(7, 2));         // outputs "C#"
System.Console.WriteLine(s3.Replace("C#", "Basic"));  // outputs "Visual Basic Express"

Es ist auch möglich, die Zeichen in ein Zeichenarray zu kopieren, z. B.:

string s4 = "Hello, World";
char[] arr = s4.ToCharArray(0, s4.Length);

foreach (char c in arr)
{
    System.Console.Write(c);  // outputs "Hello, World"
}

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]);  // outputs "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 Zeichenfolgen mit dem ==-Operator und dem !=-Operator vergleichen, die einen Vergleich unter Berücksichtigung der Groß-/Kleinschreibung durchführen.

string color1 = "red";
string color2 = "green";
string color3 = "red";

if (color1 == color3)
{
    System.Console.WriteLine("Equal");
}
if (color1 != color2)
{
    System.Console.WriteLine("Not equal");
}

Zeichenfolgenobjekte verfügen außerdem über eine CompareTo()-Methode, die einen Ganzzahlwert zurückgibt, aus dem hervorgeht, 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.

string s7 = "ABC";
string s8 = "abc";

if (s7.CompareTo(s8) > 0)
{
    System.Console.WriteLine("Greater-than");
}
else
{
    System.Console.WriteLine("Less-than");
}

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.

string s9 = "Battle of Hastings, 1066";

System.Console.WriteLine(s9.IndexOf("Hastings"));  // outputs 10
System.Console.WriteLine(s9.IndexOf("1967"));      // outputs -1

Teilen einer Zeichenfolge in Teilzeichenfolgen

Eine Zeichenfolge in Teilzeichenfolgen zu teilen, z. B. einen Satz in einzelne Wörter aufzuteilen, ist eine häufig vorkommende Programmieraufgabe. Die Split()-Methode erhält ein char-Array aus Trennzeichen (z. B. ein Leerzeichen) und gibt ein Array aus Teilzeichenfolgen zurück. Sie können auf dieses Array mit foreach zugreifen, z. B.:

char[] delimit = new char[] { ' ' };
string s10 = "The cat sat on the mat.";
foreach (string substr in s10.Split(delimit))
{
    System.Console.WriteLine(substr);
}

Dieser Code gibt jedes Wort auf einer separaten Zeile aus, z. B.:

The

cat

sat

on

the

mat.

NULL-Zeichenfolgen und leere Zeichenfolgen

Eine leere Zeichenfolge ist eine Instanz eines System.String-Objekts, die 0 (null) Zeichen enthält. Leere Zeichenfolgen werden relativ häufig in verschiedenen Programmierszenarien 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 folgendermaßen initialisiert:

string s = "";

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:

string str = "hello";
string nullStr = null;
string emptyStr = "";

string tempStr  = str + nullStr; // tempStr = "hello"
bool b = (emptyStr == nullStr);// b = false;
emptyStr + nullStr = ""; // creates a new empty string
int I  = nullStr.Length; // throws NullReferenceException

Verwenden von StringBuilder

Die StringBuilder-Klasse erstellt einen Zeichenfolgenpuffer, der eine verbesserte Leistung gewährleistet, falls Manipulation von Zeichenfolgen in Ihrem Programm häufig vorkommt. 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();

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
    }
}

Weitere Informationen

Aus der C#-Programmierreferenz:

Siehe auch

Anzeigen:
© 2014 Microsoft