Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

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.

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.

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.

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).

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."


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"

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.

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.

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


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?            


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

}


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


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.

Anzeigen: