Gewusst wie: Ändern von Zeichenfolgeninhalten (C#-Programmierhandbuch)How to: Modify String Contents (C# Programming Guide)

Da Zeichenfolgen unveränderlich sind, ist es nicht möglich (ohne unsicheren Code zu verwenden), den Wert eines Zeichenfolgenobjekts zu verändern, nachdem es erstellt wurde.Because strings are immutable, it is not possible (without using unsafe code) to modify the value of a string object after it has been created. Es gibt jedoch viele Möglichkeiten, den Wert einer Zeichenfolge zu ändern und das Ergebnis in einem neuen Zeichenfolgenobjekt zu speichern.However, there are many ways to modify the value of a string and store the result in a new string object. Die String-Klasse enthält Methoden, die eine Eingabezeichenfolge verarbeiten und ein neues Zeichenfolgenobjekt zurückgeben.The String class provides methods that operate on an input string and return a new string object. In vielen Fällen können Sie das neue Objekt der Variablen zuweisen, die die ursprüngliche Zeichenfolge enthalten hat.In many cases, you can assign the new object to the variable that held the original string. Die Regex-Klasse stellt zusätzliche Methoden bereit, die auf ähnliche Weise funktionieren.The Regex class provides additional methods that work in a similar manner. Die StringBuilder-Klasse stellt einen Puffer aus Zeichen bereit, die Sie „direkt“ ändern können.The StringBuilder class provides a character buffer that you can modify "in-place." Sie rufen die StringBuilder.ToString-Methode auf, um ein neues Zeichenfolgenobjekt zu erstellen, das die aktuellen Inhalte des Puffers enthält.You call the StringBuilder.ToString method to create a new string object that contains the current contents of the buffer.

BeispielExample

Das folgende Beispiel zeigt verschiedene Möglichkeiten, eine Teilzeichenfolgen in einer angegebenen Zeichenfolge zu ersetzen oder zu entfernen.The following example shows various ways to replace or remove substrings in a specified string.

class ReplaceSubstrings
{
    string searchFor;
    string replaceWith;

    static void Main(string[] args)
    {

        ReplaceSubstrings app = new ReplaceSubstrings();
        string s = "The mountains are behind the clouds today.";

        // Replace one substring with another with String.Replace.
        // Only exact matches are supported.
        s = s.Replace("mountains", "peaks");
        Console.WriteLine(s);
        // Output: The peaks are behind the clouds today.

        // Use Regex.Replace for more flexibility. 
        // Replace "the" or "The" with "many" or "Many".
        // using System.Text.RegularExpressions
        app.searchFor = "the"; // A very simple regular expression.
        app.replaceWith = "many";
        s = Regex.Replace(s, app.searchFor, app.ReplaceMatchCase, RegexOptions.IgnoreCase);
        Console.WriteLine(s);
        // Output: Many peaks are behind many clouds today.

        // Replace all occurrences of one char with another.
        s = s.Replace(' ', '_');
        Console.WriteLine(s);
        // Output: Many_peaks_are_behind_many_clouds_today.

        // Remove a substring from the middle of the string.
        string temp = "many_";
        int i = s.IndexOf(temp);
        if (i >= 0)
        {
            s = s.Remove(i, temp.Length);
        }
        Console.WriteLine(s);
        // Output: Many_peaks_are_behind_clouds_today.

        // Remove trailing and leading whitespace.
        // See also the TrimStart and TrimEnd methods.
        string s2 = "    I'm wider than I need to be.      ";
        // Store the results in a new string variable.
        temp = s2.Trim();
        Console.WriteLine(temp);
        // Output: I'm wider than I need to be.

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit");
        Console.ReadKey();
    }

    // Custom match method called by Regex.Replace
    // using System.Text.RegularExpressions
    string ReplaceMatchCase(Match m)
    {
        // Test whether the match is capitalized
        if (Char.IsUpper(m.Value[0]) == true)
        {
            // Capitalize the replacement string
            // using System.Text;
            StringBuilder sb = new StringBuilder(replaceWith);
            sb[0] = (Char.ToUpper(sb[0]));
            return sb.ToString();
        }
        else
        {
            return replaceWith;
        }
    }
}

BeispielExample

Um auf die einzelnen Zeichen in einer Zeichenfolge mithilfe der Arraynotation zuzugreifen, können Sie das StringBuilder-Objekt verwenden, das den []-Operator für den Zugriff auf den internen Zeichenpuffer überlädt.To access the individual characters in a string by using array notation, you can use the StringBuilder object, which overloads the [] operator to provide access to its internal character buffer. Sie können auch die Zeichenfolge mithilfe der ToCharArray-Methode in ein Array von Zeichen konvertieren.You can also convert the string to an array of chars by using the ToCharArray method. Im folgenden Beispiel wird ToCharArray zum Erstellen des Arrays verwendet.The following example uses ToCharArray to create the array. Einige Elemente dieses Arrays werden dann geändert.Some elements of this array are then modified. Ein Zeichenfolgenkonstruktor, der ein char-Array als Eingabeparameter verwendet, wird dann zum Erstellen einer neuen Zeichenfolge aufgerufen.A string constructor that takes a char array as an input parameter is then called to create a new string.

class ModifyStrings
{
    static void Main()
    {
        string str = "The quick brown fox jumped over the fence";
        System.Console.WriteLine(str);

        char[] chars = str.ToCharArray();
        int animalIndex = str.IndexOf("fox");
        if (animalIndex != -1)
        {
            chars[animalIndex++] = 'c';
            chars[animalIndex++] = 'a';
            chars[animalIndex] = 't';
        }

        string str2 = new string(chars);
        System.Console.WriteLine(str2);

        // Keep the console window open in debug mode
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
  The quick brown fox jumped over the fence
  The quick brown cat jumped over the fence 
*/

BeispielExample

Das folgende Beispiel wird für diese seltenen Fälle bereitgestellt, in denen Sie eine Zeichenfolge direkt verändern sollen, indem Sie einen unsicheren Code auf ähnliche Weise wie char-Array in C verwenden.The following example is provided for those very rare situations in which you may want to modify a string in-place by using unsafe code in a manner similar to C-style char arrays. Das Beispiel zeigt, wie Sie auf die einzelnen Zeichen „direkt“ mithilfe des festgelegten Schlüsselworts zugreifen.The example shows how to access the individual characters "in-place" by using the fixed keyword. Darüber hinaus wird ein möglicher Nebeneffekt unsicherer Vorgänge auf Zeichenfolgen gezeigt, die daraus entstehen, dass der C#-Compiler Zeichenfolgen intern speichert (hält).It also demonstrates one possible side effect of unsafe operations on strings that results from the way that the C# compiler stores (interns) strings internally. Im Allgemeinen sollten Sie dieses Verfahren nicht verwenden, es sei denn, es ist unbedingt notwendig.In general, you should not use this technique unless it is absolutely necessary.

class UnsafeString
{
    unsafe static void Main(string[] args)
    {
        // Compiler will store (intern) 
        // these strings in same location.
        string s1 = "Hello";
        string s2 = "Hello";

        // Change one string using unsafe code.
        fixed (char* p = s1)
        {
            p[0] = 'C';
        }

        //  Both strings have changed.
        Console.WriteLine(s1);
        Console.WriteLine(s2);

        // Keep console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }

}

Siehe auchSee Also

C#-ProgrammierhandbuchC# Programming Guide
ZeichenfolgenStrings