War diese Seite hilfreich?
Ihr Feedback ist uns wichtig. Teilen Sie uns Ihre Meinung mit.
Weiteres Feedback?
1500 verbleibende Zeichen
Zeichenfolgen (C#-Programmierhandbuch)
Collapse the table of content
Expand the table of content
Dieser Artikel wurde manuell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen.
Übersetzung
Original

Zeichenfolgen (C#-Programmierhandbuch)

Eine Zeichenfolge ist ein Objekt vom Typ String, dessen Wert Text ist. Intern wird der Text als sequenzielle schreibgeschützte Auflistung von Char-Objekten gespeichert. Eine C#-Zeichenfolge wird nicht mit einem NULL-Zeichen am Ende abgeschlossen. Deshalb kann eine C#-Zeichenfolge eine beliebige Anzahl eingebetteter NULL-Zeichen ('\0') enthalten. Die Length-Eigenschaft einer Zeichenfolge stellt die Anzahl der in ihr enthaltenen Char-Objekte und nicht die Anzahl von Unicode-Zeichen dar. 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

Zeilenumbruch

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"

HinweisHinweis

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. Die wörtliche Zeichenfolge @"C:\files.txt" wird beispielsweise 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 = String.Empty;

    string tempStr = str + nullStr;
    // The following line displays "hello."
    Console.WriteLine(tempStr);

    bool b = (emptyStr == nullStr);
    // The following line displays False.
    Console.WriteLine(b);

    // The following line creates a new empty string.
    string newStr = emptyStr + nullStr;

    // Null strings and empty strings behave differently. The following
    // two lines display 0.
    Console.WriteLine(emptyStr.Length);
    Console.WriteLine(newStr.Length);
    // The following line raises a NullReferenceException.
    //Console.WriteLine(nullStr.Length);

    // The null character can be displayed and counted, like other chars.
    string s1 = "\x0" + "abc";
    string s2 = "abc" + "\x0";
    // The following line displays "* abc*".
    Console.WriteLine("*" + s1 + "*");
    // The following line displays "abc *".
    Console.WriteLine("*" + s2 + "*");
    // The following line displays 4.
    Console.WriteLine(s2.Length);
}


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 finden Sie unter LINQ und Zeichenfolgen.

Thema

Beschreibung

Gewusst wie: Ändern von Zeichenfolgeninhalten (C#-Programmierhandbuch)

Veranschaulicht anhand eines Codebeispiels, wie der Inhalt von Zeichenfolgen geändert wird.

Gewusst wie: Verketten von mehreren Zeichenfolgen (C#-Programmierhandbuch)

Illustriert, wie der Operator + und die Stringbuilder-Klasse zum Verknüpfen von Zeichenfolgen zur Kompilierungs- und Laufzeit verwendet werden.

Gewusst wie: Vergleichen von Zeichenfolgen (C#-Programmierhandbuch)

Zeigt, wie ein Ordinalvergleich von Zeichenfolgen ausgeführt wird.

Gewusst wie: Aufteilen von Zeichenfolgen (C#-Programmierhandbuch)

Enthält ein Codebeispiel, das illustriert, wie die String.Split-Methode zum Analysieren von Zeichenfolgen verwendet wird.

Gewusst wie: Suchen von Zeichenfolgen mithilfe von Zeichenfolgenmethoden (C#-Programmierhandbuch)

Erklärt, wie bestimmte Methoden zum Suchen von Zeichenfolgen verwendet werden.

Gewusst wie: Suchen von Zeichenfolgen mithilfe von regulären Ausdrücken (C#-Programmierhandbuch)

Erklärt, wie reguläre Ausdrücke zum Suchen von Zeichenfolgen verwendet werden.

Gewusst wie: Bestimmen, ob eine Zeichenfolge einen numerischen Wert darstellt (C#-Programmierhandbuch)

Zeigt, wie eine Zeichenfolge sicher analysiert wird, um zu sehen, ob es einen gültigen numerischen Wert hat.

Gewusst wie: Konvertieren einer Zeichenfolge in einen DateTime-Wert (C#-Programmierhandbuch)

Zeigt, wie eine Zeichenfolge, z. B. "01/24/2008", in ein System.DateTime-Objekt konvertiert wird.

Grundlegende Zeichenfolgenoperationen

Stellt Links zu Themen über die Verwendung der System.String-Methode und der System.Text.StringBuilder-Methode zur Ausführung grundlegender Zeichenfolgenoperationen bereit.

Verarbeiten von Zeichenfolgen

Beschreibt, wie Zeichen oder Leerzeichen in eine Zeichenfolge eingefügt werden.

Vergleichen von Zeichenfolgen

Enthält Informationen darüber, wie Zeichenfolgen verglichen werden, und bietet Beispiele in C# und Visual Basic.

Verwenden der StringBuilder-Klasse

Beschreibt, wie dynamische Zeichenfolgenobjekte mit der StringBuilder-Klasse erstellt und geändert werden.

LINQ und Zeichenfolgen

Enthält Informationen darüber, wie verschiedene Zeichenfolgenoperationen mit LINQ-Abfragen durchgeführt werden.

C#-Programmierhandbuch

Bietet Links zu Themen, in denen Programmierkonstrukte von C# beschrieben werden.

Datum

Versionsgeschichte

Grund

Juni 2010

Beschreibung der Length-Eigenschaft klarer formuliert.

Kundenfeedback.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft