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

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. Es gibt jedoch viele Möglichkeiten, den Wert einer Zeichenfolge zu ändern und das Ergebnis in einem neuen Zeichenfolgenobjekt zu speichern. Die <xref:System.String?displayProperty=fullName>-Klasse enthält Methoden, die eine Eingabezeichenfolge verarbeiten und ein neues Zeichenfolgenobjekt zurückgeben. In vielen Fällen können Sie das neue Objekt der Variablen zuweisen, die die ursprüngliche Zeichenfolge enthalten hat. Die <xref:System.Text.RegularExpressions.Regex?displayProperty=fullName>-Klasse stellt zusätzliche Methoden bereit, die auf ähnliche Weise funktionieren. Die <xref:System.Text.StringBuilder?displayProperty=fullName>-Klasse stellt einen Puffer aus Zeichen bereit, die Sie „direkt“ ändern können. Sie rufen die <xref:System.Text.StringBuilder.ToString%2A?displayProperty=fullName>-Methode auf, um ein neues Zeichenfolgenobjekt zu erstellen, das die aktuellen Inhalte des Puffers enthält.

Beispiel

Das folgende Beispiel zeigt verschiedene Möglichkeiten, eine Teilzeichenfolgen in einer angegebenen Zeichenfolge zu ersetzen oder zu entfernen.

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

Beispiel

Um auf die einzelnen Zeichen in einer Zeichenfolge mithilfe der Arraynotation zuzugreifen, können Sie das <xref:System.Text.StringBuilder>-Objekt verwenden, das den []-Operator für den Zugriff auf den internen Zeichenpuffer überlädt. Sie können auch die Zeichenfolge mithilfe der <xref:System.String.ToCharArray%2A>-Methode in ein Array von Zeichen konvertieren. Im folgenden Beispiel wird ToCharArray zum Erstellen des Arrays verwendet. Einige Elemente dieses Arrays werden dann geändert. Ein Zeichenfolgenkonstruktor, der ein char-Array als Eingabeparameter verwendet, wird dann zum Erstellen einer neuen Zeichenfolge aufgerufen.

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 
*/

Beispiel

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. Das Beispiel zeigt, wie Sie auf die einzelnen Zeichen „direkt“ mithilfe des festgelegten Schlüsselworts zugreifen. 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). Im Allgemeinen sollten Sie dieses Verfahren nicht verwenden, es sei denn, es ist unbedingt notwendig.

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 auch

C#-Programmierhandbuch
Zeichenfolgen