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

Aktualisiert: Juli 2008

Da Zeichenfolgen unveränderlich sind, ist es (ohne Verwendung von unsicheren Code) nicht möglich, den Wert eines Zeichenfolgenobjekts zu ä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 System.String-Klasse stellt Methoden bereit, die für eine Eingabezeichenfolge ausgeführt werden und ein neues Zeichenfolgenobjekt zurückgeben. In vielen Fällen können Sie der Variablen, die die ursprüngliche Zeichenfolge enthielt, das neue Objekt zuweisen. Die System.Text.RegularExpressions.Regex-Klasse stellt zusätzliche Methoden bereit, die auf ähnliche Weise funktionieren. Die System.Text.StringBuilder-Klasse stellt einen Zeichenpuffer bereit, den Sie "direkt" ändern können. Sie rufen die StringBuilder.ToString-Methode zum Erstellen eines neuen Zeichenfolgenobjekts auf, das den aktuellen Inhalt des Puffers enthält.

Beispiel

Im folgenden Beispiel werden verschiedene Möglichkeiten dargestellt, 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;
        }
    }
}

Um auf die einzelnen Zeichen in einer Zeichenfolge mithilfe der Arraynotation zuzugreifen, können Sie das StringBuilder-Objekt, das den []-Operator überlädt, für den Zugriff auf den internen Zeichenpuffer verwenden. Sie können auch die Zeichenfolge mit der ToCharArray-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 Zeichenarray als Eingabeparameter akzeptiert, 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 
*/

Das folgende Beispiel gilt für die sehr seltenen Situationen, in denen Sie eine Zeichenfolge mithilfe des unsicheren Codes direkt ändern möchten, ähnlich wie bei Zeichenfolgenarrays im C-Format. Es wird dargestellt, wie mit dem fixed-Schlüsselwort direkt auf die einzelnen Zeichen zugegriffen wird. Es zeigt auch einen möglichen Nebeneffekt von unsicheren Operationen für Zeichenfolgen, der daraus resultiert, wie der C#-Compiler Zeichenfolgen intern speichert. Im Allgemeinen sollten Sie diese Methode nicht verwenden, wenn es nicht absolut notwendig ist.

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

Konzepte

C#-Programmierhandbuch

Referenz

Zeichenfolgen (C#-Programmierhandbuch)

Änderungsverlauf

Date	Versionsgeschichte	Grund
Juli 2008	Umfangreiche Änderungen und zusätzliche Codebeispiele zur Verbesserung der Genauigkeit und Vollständigkeit.	Korrektur inhaltlicher Fehler.