Zeichenfolgen (C#-Programmierhandbuch)Strings (C# Programming Guide)

Eine Zeichenfolge ist ein Objekt des Typs String, dessen Wert Text ist.A string is an object of type String whose value is text. Intern wird der Text als sequenzielle schreibgeschützte Auflistung von Char-Objekten gespeichert.Internally, the text is stored as a sequential read-only collection of Char objects. Es gibt kein mit NULL endendes Zeichen am Ende einer C#-Zeichenfolge. Deshalb kann eine C#-Zeichenfolge eine beliebige Anzahl eingebetteter NULL-Zeichen („\0“) enthalten.There is no null-terminating character at the end of a C# string; therefore a C# string can contain any number of embedded null characters ('\0'). Die Eigenschaft Length einer Zeichenfolge stellt die Anzahl von Char-Objekten dar, die darin enthalten sind, nicht die Anzahl der Unicode-Zeichen.The Length property of a string represents the number of Char objects it contains, not the number of Unicode characters. Verwenden Sie für den Zugriff auf einzelne Unicode-Codepunkte in einer Zeichenfolge das Objekt StringInfo.To access the individual Unicode code points in a string, use the StringInfo object.

String im Vergleich zu System.Stringstring vs. System.String

In C# ist das Schlüsselwort string ein Alias für String.In C#, the string keyword is an alias for String. Aus diesem Grund sind String und string gleich, und Sie können eine beliebige Benennungskonvention verwenden.Therefore, String and string are equivalent, and you can use whichever naming convention you prefer. Die String-Klasse bietet viele Methoden zum sicheren Erstellen, Bearbeiten und Vergleichen von Zeichenfolgen.The String class provides many methods for safely creating, manipulating, and comparing strings. Außerdem überlädt die Programmiersprache C# einige Operatoren, um allgemeine Zeichenfolgenoperationen zu vereinfachen.In addition, the C# language overloads some operators to simplify common string operations. Weitere Informationen über das Schlüsselwort finden Sie unter String.For more information about the keyword, see string. Weitere Informationen zum Typ und dessen Methoden finden Sie unter String.For more information about the type and its methods, see String.

Deklarieren und Initialisieren von ZeichenfolgenDeclaring and Initializing Strings

Sie können Zeichenfolgen auf verschiedene Weise deklarieren und Initialisieren, wie im folgenden Beispiel gezeigt:You can declare and initialize strings in various ways, as shown in the following example:

// 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 nicht den neuen Operator zum Erstellen eines Zeichenfolgenobjekts verwenden, außer wenn Sie die Zeichenfolge mit einem Array von Chars initialisieren.Note that you do not use the new operator to create a string object except when initializing the string with an array of chars.

Initialisieren Sie eine Zeichenfolge mit dem konstanten Wert Empty, um ein neues String-Objekt zu erstellen, dessen Zeichenfolge eine Länge von 0 hat.Initialize a string with the Empty constant value to create a new String object whose string is of zero length. Die Darstellung des Zeichenfolgenliterals einer Zeichenfolge mit einer Länge von 0 ist "".The string literal representation of a zero-length string is "". Indem Zeichenfolgen mit dem Wert Empty anstatt NULL initialisiert werden, können Sie die Chancen einer auftretenden NullReferenceException reduzieren.By initializing strings with the Empty value instead of null, you can reduce the chances of a NullReferenceException occurring. Verwenden Sie die statische Methode IsNullOrEmpty(String), um den Wert einer Zeichenfolge zu überprüfen, bevor Sie versuchen, auf sie zuzugreifen.Use the static IsNullOrEmpty(String) method to verify the value of a string before you try to access it.

Unveränderlichkeit von ZeichenfolgenobjektenImmutability of String Objects

Zeichenfolgenobjekte sind unveränderlich: sie können nicht geändert werden, nachdem sie erstellt wurden.String objects are immutable: they cannot be changed after they have been created. Alle String-Methoden und C#-Operatoren, die eine Zeichenfolge scheinbar verändern, geben in Wirklichkeit die Ergebnisse in einem neuen Zeichenfolgenobjekt zurück.All of the String methods and C# operators that appear to modify a string actually return the results in a new string object. Im folgenden Beispiel werden die beiden ursprünglichen Zeichenfolgen nicht geändert, wenn die Inhalte von s1 und s2 verkettet werden, um eine einzelne Zeichenfolge zu bilden.In the following example, when the contents of s1 and s2 are concatenated to form a single string, the two original strings are unmodified. Der +=-Operator erstellt eine neue Zeichenfolge, die die kombinierten Inhalte enthält.The += operator creates a new string that contains the combined contents. Das neue Objekt wird der Variablen s1 zugewiesen, und das ursprüngliche Objekt, das s1 zugewiesen wurde, wird für die Garbage Collection freigegeben, da keine andere Variable einen Verweis darauf enthält.That new object is assigned to the variable s1, and the original object that was assigned to s1 is released for garbage collection because no other variable holds a reference to it.

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“ in Wirklichkeit eine neue Erstellung von Zeichenfolgen ist, müssen Sie vorsichtig sein, wenn Sie Verweise auf Zeichenfolgen erstellen.Because a string "modification" is actually a new string creation, you must use caution when you create references to strings. Wenn Sie einen Verweis auf eine Zeichenfolge erstellen und dann die ursprüngliche Zeichenfolge „ändern“, wird der Verweis weiterhin auf das ursprüngliche Objekt anstelle des neuen Objekts zeigen, das erstellt wurde, als die Zeichenfolge geändert wurde.If you create a reference to a string, and then "modify" the original string, the reference will continue to point to the original object instead of the new object that was created when the string was modified. Der folgende Code veranschaulicht dieses Verhalten:The following code illustrates this behavior:

string s1 = "Hello ";
string s2 = s1;
s1 += "World";

System.Console.WriteLine(s2);
//Output: Hello

Weitere Informationen zum Erstellen neuer Zeichenfolgen, die auf Änderungen wie Vorgänge zum Suchen und Ersetzen auf der ursprüngliche Zeichenfolge basieren, finden Sie unter Vorgehensweise: Ändern von Zeichenfolgeninhalten.For more information about how to create new strings that are based on modifications such as search and replace operations on the original string, see How to: Modify String Contents.

Reguläre und ausführliche ZeichenfolgenliteraleRegular and Verbatim String Literals

Verwenden Sie reguläre Zeichenfolgenliterale, wenn Sie von C# bereitgestellte Escapezeichen einbetten müssen, wie im folgenden Beispiel gezeigt:Use regular string literals when you must embed escape characters provided by C#, as shown in the following example:

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 ausführliche Zeichenfolgen der Einfachheit und Lesbarkeit halber, wenn der Text der Zeichenfolge umgekehrte Schrägstriche enthält, z.B. in Dateipfaden.Use verbatim strings for convenience and better readability when the string text contains backslash characters, for example in file paths. Da ausführliche Zeichenfolgen neue Zeilenzeichen als Teil des Texts der Zeichenfolge beibehalten, können sie verwendet werden, um mehrzeilige Zeichenfolgen zu initialisieren.Because verbatim strings preserve new line characters as part of the string text, they can be used to initialize multiline strings. Verwenden Sie doppelte Anführungszeichen, um ein Anführungszeichen in eine ausführliche Zeichenfolge einzubetten.Use double quotation marks to embed a quotation mark inside a verbatim string. Im folgenden Beispiel werden einige gängige Verwendungszwecke für allgemeine Zeichenfolgen dargestellt:The following example shows some common uses for verbatim strings:

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-EscapesequenzenString Escape Sequences

EscapesequenzEscape sequence ZeichennameCharacter name Unicode-CodierungUnicode encoding
\'\' Einfaches AnführungszeichenSingle quote 0x00270x0027
\"\" Doppeltes AnführungszeichenDouble quote 0x00220x0022
\\ Umgekehrter SchrägstrichBackslash 0x005C0x005C
\0\0 NullNull 0x00000x0000
\a\a WarnungAlert 0x00070x0007
\b\b RückschrittBackspace 0x00080x0008
\f\f SeitenvorschubForm feed 0x000C0x000C
\n ZeilenwechselNew line 0x000A0x000A
\r\r WagenrücklaufCarriage return 0x000D0x000D
\t\t Horizontaler TabulatorHorizontal tab 0x00090x0009
\U\U Unicode-Escapesequenz für ErsatzzeichenpaareUnicode escape sequence for surrogate pairs. \Unnnnnnnn\Unnnnnnnn
\u\u Unicode-EscapesequenzUnicode escape sequence \u0041 = "A"\u0041 = "A"
\v\v Vertikaler TabulatorVertical tab 0x000B0x000B
\x\x Unicode-Escapesequenz, die ähnlich wie "\u" ist, außer mit variabler LängeUnicode escape sequence similar to "\u" except with variable length. \x0041 = "A"\x0041 = "A"

Hinweis

Zum Zeitpunkt der Kompilierung werden ausführliche Zeichenfolgen in normale Zeichenfolgen mit gleichen Escapesequenzen konvertiert.At compile time, verbatim strings are converted to ordinary strings with all the same escape sequences. Aus diesem Grund sehen Sie die Escapezeichen, die vom Compiler hinzugefügt werden, und nicht die ausführliche Version aus Ihrem Sourcecode, wenn Sie eine ausführliche Zeichenfolge in Debugger-Überwachungsfenster anzeigen.Therefore, if you view a verbatim string in the debugger watch window, you will see the escape characters that were added by the compiler, not the verbatim version from your source code. Die ausführliche Zeichenfolge @"C:\files.txt" wird im Überwachungsfenster z.B. als „C:\\files.txt“ angezeigt.For example, the verbatim string @"C:\files.txt" will appear in the watch window as "C:\\files.txt".

FormatzeichenfolgenFormat Strings

Eine Formatzeichenfolge ist eine Zeichenfolge, deren Inhalt zur Laufzeit dynamisch bestimmt werden kann.A format string is a string whose contents can be determined dynamically at runtime. Sie erstellen eine Zeichenfolge mithilfe der statischen Format-Methode und betten Platzhalter in geschweiften Klammern ein, die durch andere Werte zur Laufzeit ersetzt werden.You create a format string by using the static Format method and embedding placeholders in braces that will be replaced by other values at runtime. Das folgende Beispiel verwendet eine Formatzeichenfolge, um das Ergebnis jeder Iteration einer Schleife auszugeben:The following example uses a format string to output the result of each iteration of a loop:

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.One overload of the WriteLine method takes a format string as a parameter. Aus diesem Grund können Sie nur ein Formatzeichenfolgenliteral ohne den expliziten Aufruf der Methode einbetten.Therefore, you can just embed a format string literal without an explicit call to the method. Wenn Sie jedoch die WriteLine-Methode zum Anzeigen der Debugausgabe im Ausgabefenster von Visual Studio verwenden, müssen Sie explizit die Format-Methode aufrufen, da WriteLine nur eine Zeichenfolge und keine Formatzeichenfolge akzeptiert.However, if you use the WriteLine method to display debug output in the Visual Studio Output window, you have to explicitly call the Format method because WriteLine only accepts a string, not a format string. Weitere Informationen zu Formatzeichenfolgen finden Sie unter Formatierung von Typen.For more information about format strings, see Formatting Types.

TeilzeichenfolgenSubstrings

Eine Teilzeichenfolge ist eine beliebige Sequenz von Zeichen, die in einer Zeichenfolge enthalten ist.A substring is any sequence of characters that is contained in a string. Verwenden Sie die Substring-Methode, um eine neue Zeichenfolge aus einem Teil der ursprünglichen Zeichenfolge zu erstellen.Use the Substring method to create a new string from a part of the original string. Sie können nach einem oder mehreren Vorkommnissen einer Teilzeichenfolge suchen, indem Sie die IndexOf-Methode verwenden.You can search for one or more occurrences of a substring by using the IndexOf method. Verwenden Sie die Replace-Methode, um alle Vorkommnisse einer angegebenen Teilzeichenfolge mit einer neuen Zeichenfolge zu ersetzen.Use the Replace method to replace all occurrences of a specified substring with a new string. Genauso wie die Substring-Methode gibt Replace tatsächlich eine neue Zeichenfolge zurück und ändert nicht die ursprüngliche Zeichenfolge.Like the Substring method, Replace actually returns a new string and does not modify the original string. Weitere Informationen finden Sie unter Vorgehensweise: Suchen von Zeichenfolgen mithilfe von Zeichenfolgenmethoden und Vorgehensweise: Ändern von Zeichenfolgeninhalten.For more information, see How to: Search Strings Using String Methods and How to: Modify String Contents.

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 ZeichenAccessing Individual Characters

Sie können die Arraynotation mit einem Indexwert verwenden, um schreibgeschützten Zugriff auf einzelne Zeichen zu erhalten, so wie in folgendem Beispiel gezeigt:You can use array notation with an index value to acquire read-only access to individual characters, as in the following example:

string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)
{
    System.Console.Write(s5[s5.Length - i - 1]);
}
// Output: "sdrawkcab gnitnirP"

Wenn die String-Methoden nicht die Funktionen bieten, die Sie zum Bearbeiten einzelner Zeichen in einer Zeichenfolge benötigen, können Sie ein StringBuilder-Objekt verwenden, um die einzelnen Chars „direkt“ zu bearbeiten und anschließend eine neue Zeichenfolge zu StringBuilder-Methoden zu speichern.If the String methods do not provide the functionality that you must have to modify individual characters in a string, you can use a StringBuilder object to modify the individual chars "in-place", and then create a new string to store the results by using the StringBuilder methods. Im folgenden Beispiel wird davon ausgegangen, dass Sie die ursprüngliche Zeichenfolge auf eine bestimmte Weise ändern und die Ergebnisse für die zukünftige Verwendung speichern müssen:In the following example, assume that you must modify the original string in a particular way and then store the results for future use:

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 ZeichenfolgenNull Strings and Empty Strings

Eine leere Zeichenfolge ist eine Instanz eines System.String-Objekts, dass 0 Zeichen enthält.An empty string is an instance of a System.String object that contains zero characters. Leere Zeichenfolgen werden häufig in verschiedenen Programmierszenarios verwendet, um ein leeres Textfeld darzustellen.Empty strings are used often in various programming scenarios to represent a blank text field. Sie können Methoden für leere Zeichenfolgen aufrufen, da sie gültige System.String-Objekte sind.You can call methods on empty strings because they are valid System.String objects. Leere Zeichenfolgen werden wie folgt initialisiert:Empty strings are initialized as follows:

string s = String.Empty;  

Im Gegensatz dazu, verweist eine NULL-Zeichenfolge nicht auf eine Instanz eines System.String-Objekts und jeder Versuch, eine Methode für eine NULL-Zeichenfolge aufzurufen, löst eine NullReferenceException aus.By contrast, a null string does not refer to an instance of a System.String object and any attempt to call a method on a null string causes a NullReferenceException. Allerdings können Sie NULL-Zeichenfolgen in Verkettungs- und Vergleichsoperationen mit anderen Zeichenfolgen verwenden.However, you can use null strings in concatenation and comparison operations with other strings. Die folgenden Beispiele veranschaulichen einige Fälle, in denen ein Verweis auf eine NULL-Zeichenfolge nicht dazu führt, dass eine Ausnahme ausgelöst wird:The following examples illustrate some cases in which a reference to a null string does and does not cause an exception to be thrown:

static void Main()
{
    string str = "hello";
    string nullStr = null;
    string emptyStr = String.Empty;

    string tempStr = str + nullStr;
    // Output of the following line: hello
    Console.WriteLine(tempStr);

    bool b = (emptyStr == nullStr);
    // Output of the following line: 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";
    // Output of the following line: * abc*
    Console.WriteLine("*" + s1 + "*");
    // Output of the following line: *abc *
    Console.WriteLine("*" + s2 + "*");
    // Output of the following line: 4
    Console.WriteLine(s2.Length);
}

Verwenden von StringBuilder für die schnelle Erstellung von ZeichenfolgenUsing StringBuilder for Fast String Creation

Zeichenfolgenoperationen in .NET werden hochgradig optimiert und wirken sich in den meisten Fällen nicht erheblich auf die Leistung aus.String operations in .NET are highly optimized and in most cases do not significantly impact performance. In einigen Szenarios, z.B. in engen Schleifen, die Hunderttausende Male ausgeführt werden, können sich Zeichenfolgenoperationen auf die Leistung auswirken.However, in some scenarios such as tight loops that are executing many hundreds or thousands of times, string operations can affect performance. Die StringBuilder-Klasse erstellt einen Zeichenfolgenpuffer, der eine verbesserte Leistung mit sich bringt, wenn Ihr Programm viele Zeichenfolgenbearbeitungen durchführt.The StringBuilder class creates a string buffer that offers better performance if your program performs many string manipulations. Mit der StringBuilder-Zeichenfolge können Sie auch einzelne Zeichen erneut zuweisen, was der integrierte String-Datentyp nicht unterstützt.The StringBuilder string also enables you to reassign individual characters, something the built-in string data type does not support. Dieser Code ändert z.B. den Inhalt einer Zeichenfolge ohne eine neue Zeichenfolge zu erstellen:This code, for example, changes the content of a string without creating a new string:

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 zum Erstellen einer Zeichenfolge aus einem Satz von numerischen Typen verwendet:In this example, a StringBuilder object is used to create a string from a set of numeric types:

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 LINQStrings, Extension Methods and LINQ

Da der String-Typ IEnumerable<T> implementiert, können Sie die Erweiterungsmethode verwenden, die in der Enumerable-Klasse auf Zeichenfolgen definiert ist.Because the String type implements IEnumerable<T>, you can use the extension methods defined in the Enumerable class on strings. Um „visuelle Überfrachtung“ zu vermeiden, werden diese Methode für den String-Typ aus IntelliSense ausgeschlossen, nichtsdestotrotz sind sie weiterhin verfügbar.To avoid visual clutter, these methods are excluded from IntelliSense for the String type, but they are available nevertheless. Sie können auch LINQLINQ-Abfrageausdrücke in Zeichenfolgen verwenden.You can also use LINQLINQ query expressions on strings. Weitere Informationen finden Sie unter LINQ und Zeichenfolgen.For more information, see LINQ and Strings.

ThemaTopic BeschreibungDescription
Gewusst wie: Ändern von ZeichenfolgeninhaltenHow to: Modify String Contents Enthält ein Codebeispiel, das zeigt, wie die Inhalte von Zeichenfolgen geändert werdenProvides a code example that illustrates how to modify the contents of strings.
Gewusst wie: Verketten von mehreren ZeichenfolgenHow to: Concatenate Multiple Strings Veranschaulicht, wie der +-Operator und die Stringbuilder-Klasse verwendet werden, um Zeichenfolgen zur Kompilierzeit und Laufzeit zu verknüpfenIllustrates how to use the + operator and the Stringbuilder class to join strings together at compile time and run time.
Gewusst wie: Vergleichen von ZeichenfolgenHow to: Compare Strings Zeigt, wie Ordinalzahlenvergleiche von Zeichenfolgen durchgeführt werdenShows how to perform ordinal comparisons of strings.
Vorgehensweise: Analysieren von Zeichenfolgen mithilfe von String.SplitHow to: Parse Strings Using String.Split Enthält ein Codebeispiel, das veranschaulicht, wie Sie die String.Split-Methode zum Analysieren von Zeichenfolgen verwendenContains a code example that illustrates how to use the String.Split method to parse strings.
Gewusst wie: Suchen von Zeichenfolgen mithilfe von ZeichenfolgenmethodenHow to: Search Strings Using String Methods Erläutert, wie bestimmte Methoden zum Suchen von Zeichenfolgen verwendet werdenExplains how to use specific methods to search strings.
Gewusst wie: Suchen von Zeichenfolgen mithilfe von regulären AusdrückenHow to: Search Strings Using Regular Expressions Erläutert, wie reguläre Ausdrücken zum Suchen von Zeichenfolgen verwendet werdenExplains how to use regular expressions to search strings.
Gewusst wie: Bestimmen, ob eine Zeichenfolge einen numerischen Wert darstelltHow to: Determine Whether a String Represents a Numeric Value Zeigt, wie Sie sicher eine Zeichenfolge analysieren, um zu sehen, ob diese über einen gültigen numerischen Wert verfügtShows how to safely parse a string to see whether it has a valid numeric value.
Gewusst wie: Konvertieren einer Zeichenfolge in einen DateTime-WertHow to: Convert a String to a DateTime Zeigt, wie eine Zeichenfolge wie "01/24/2008" in ein System.DateTime-Objekt konvertiert wirdShows how to convert a string such as "01/24/2008" to a System.DateTime object.
Grundlegende ZeichenfolgenoperationenBasic String Operations Stellt Links zu Themen bereit, die System.String- und System.Text.StringBuilder-Methoden verwenden, um grundlegende Zeichenfolgenoperationen durchzuführenProvides links to topics that use System.String and System.Text.StringBuilder methods to perform basic string operations.
Analysieren von ZeichenfolgenParsing Strings Beschreibt, wie Zeichen oder Leerzeichen in eine Zeichenfolge eingefügt werdenDescribes how to insert characters or empty spaces into a string.
Vergleichen von ZeichenfolgenComparing Strings Enthält Informationen, wie Zeichenfolgen verglichen werden, und gibt Beispiele in C# und Visual BasicIncludes information about how to compare strings and provides examples in C# and Visual Basic.
Verwenden der StringBuilder-KlasseUsing the StringBuilder Class Beschreibt das Erstellen und Ändern dynamischer Zeichenfolgenobjekte mithilfe der StringBuilder-KlasseDescribes how to create and modify dynamic string objects by using the StringBuilder class.
LINQ und ZeichenfolgenLINQ and Strings Enthält Informationen zum Ausführen verschiedener Zeichenfolgenoperationen mithilfe von LINQ-AbfragenProvides information about how to perform various string operations by using LINQ queries.
C#-ProgrammierhandbuchC# Programming Guide Enthält Links zu Themen, in denen die Konstrukte der Programmierung in C# beschrieben werdenProvides links to topics that explain programming constructs in C#.