Vorgehensweise: Ändern von Zeichenfolgeninhalten in C#

In diesem Artikel werden verschiedene Methoden zum Erzeugen einer string durch Modifizieren einer vorhandenen string erläutert. Alle diese gezeigten Methoden geben das Ergebnis der Modifizierung als neues string-Objekt zurück. Die Beispiele speichern das Ergebnis in einer neuen Variable, um zu zeigen, dass es sich bei den ursprünglichen und den bearbeiteten Zeichenfolgen um unterschiedliche Instanzen handelt. Sie können die ursprüngliche string und die neue, bearbeitete string untersuchen, wenn Sie die einzelnen Beispiele ausführen.

In diesem Artikel werden mehrere Methoden aufgezeigt. Sie können vorhandenen Text ersetzen. Sie können nach Mustern suchen und übereinstimmenden Text durch anderen Text ersetzen. Sie können Zeichenfolgen als Zeichensequenzen behandeln. Sie können zudem Hilfsmethoden verwenden, die Leerräume entfernen. Verwenden Sie diejenigen Methoden, die am besten zu Ihrem Szenario passen.

Ersetzen von Text

Der folgende Code erstellt eine neue Zeichenfolge, indem er vorhandenen Text ersetzt.

string source = "The mountains are behind the clouds today.";

// Replace one substring with another with String.Replace.
// Only exact matches are supported.
var replacement = source.Replace("mountains", "peaks");
Console.WriteLine($"The source string is <{source}>");
Console.WriteLine($"The updated string is <{replacement}>");

Der vorherige Code veranschaulicht diese unveränderliche Eigenschaft von Zeichenfolgen. Im vorherigen Beispiel können Sie sehen, dass die ursprüngliche Zeichenfolge source nicht modifiziert wird. Die Methode String.Replace erstellt eine neue string, die die Modifizierungen enthält.

Die Methode Replace kann entweder Zeichenfolgen oder einzelne Zeichen ersetzen. In beiden Fällen wird jedes Vorkommen des gesuchten Texts ersetzt. In folgendem Beispiel werden alle „ “-Zeichen durch „_“ ersetzt:

string source = "The mountains are behind the clouds today.";

// Replace all occurrences of one char with another.
var replacement = source.Replace(' ', '_');
Console.WriteLine(source);
Console.WriteLine(replacement);

Die Quellzeichenfolge bleibt unverändert, und es wird eine neue Zeichenfolge mit der Ersetzung zurückgegeben.

Entfernen von Leerräumen

Sie können die Methoden String.Trim, String.TrimStart und String.TrimEnd verwenden, um führende oder nachfolgende Leerräume zu entfernen. Im folgenden Code ist ein Beispiel für jede Methode dargestellt. Die Quellzeichenfolge bleibt unverändert. Diese Methoden geben eine neue Zeichenfolge mit modifiziertem Inhalt zurück.

// Remove trailing and leading white space.
string source = "    I'm wider than I need to be.      ";
// Store the results in a new string variable.
var trimmedResult = source.Trim();
var trimLeading = source.TrimStart();
var trimTrailing = source.TrimEnd();
Console.WriteLine($"<{source}>");
Console.WriteLine($"<{trimmedResult}>");
Console.WriteLine($"<{trimLeading}>");
Console.WriteLine($"<{trimTrailing}>");

Entfernen von Text

Mit der Methode String.Remove können Sie Text aus einer Zeichenfolge entfernen. Diese Methode entfernt mehrere Zeichen ab einem spezifischen Index. In folgendem Beispiel wird gezeigt, wie Sie String.IndexOf gefolgt von Remove verwenden können, um Text aus einer Zeichenfolge zu entfernen:

string source = "Many mountains are behind many clouds today.";
// Remove a substring from the middle of the string.
string toRemove = "many ";
string result = string.Empty;
int i = source.IndexOf(toRemove);
if (i >= 0)
{
    result= source.Remove(i, toRemove.Length);
}
Console.WriteLine(source);
Console.WriteLine(result);

Ersetzen von übereinstimmenden Mustern

Sie können reguläre Ausdrücke verwenden, um Text, der mit Mustern übereinstimmt, durch neuen Text zu ersetzen, der auch durch ein Muster definiert werden kann. In folgendem Beispiel wird die Klasse System.Text.RegularExpressions.Regex verwendet, um ein Muster in einer Quellzeichenfolge zu finden und dieses durch Text mit korrekter Großschreibung zu ersetzen. Die Methode Regex.Replace(String, String, MatchEvaluator, RegexOptions) akzeptiert eine Funktion, die die Logik der Ersetzung als eines ihrer Argumente bereitstellt. In diesem Beispiel ist diese Funktion LocalReplaceMatchCase eine lokale Funktion, die in der Beispielmethode deklariert wird. LocalReplaceMatchCase verwendet die System.Text.StringBuilder-Klasse zum Erstellen der Ersatzzeichenfolge mit korrekter Großschreibung.

Reguläre Ausdrücke sind besonders beim Suchen und Ersetzen von Text nützlich, der einem bestimmten Muster folgt, und nicht so sehr bei bekanntem Text. Weitere Informationen finden Sie unter Vorgehensweise: Durchsuchen von Zeichenfolgen. Das Suchmuster „the\s“ sucht nach dem Wort „the“ gefolgt von einem Leerzeichen. Der Teil des Musters stellt sicher, das es nicht „there“ als Übereinstimmung in der Quellzeichenfolge ansieht. Weitere Informationen zur Sprache für reguläre Ausdrücke finden Sie unter Sprachelemente für reguläre Ausdrücke – Kurzübersicht.

string source = "The mountains are still there behind the clouds today.";

// Use Regex.Replace for more flexibility.
// Replace "the" or "The" with "many" or "Many".
// using System.Text.RegularExpressions
string replaceWith = "many ";
source = System.Text.RegularExpressions.Regex.Replace(source, "the\\s", LocalReplaceMatchCase,
    System.Text.RegularExpressions.RegexOptions.IgnoreCase);
Console.WriteLine(source);

string LocalReplaceMatchCase(System.Text.RegularExpressions.Match matchExpression)
{
    // Test whether the match is capitalized
    if (Char.IsUpper(matchExpression.Value[0]))
    {
        // Capitalize the replacement string
        System.Text.StringBuilder replacementBuilder = new System.Text.StringBuilder(replaceWith);
        replacementBuilder[0] = Char.ToUpper(replacementBuilder[0]);
        return replacementBuilder.ToString();
    }
    else
    {
        return replaceWith;
    }
}

Die Methode StringBuilder.ToString gibt eine unveränderliche Zeichenfolge zurück, die den Inhalt im StringBuilder-Objekt enthält.

Modifizieren einzelner Zeichen

Sie können ein Zeichenarray aus einer Zeichenfolge erzeugen, den Inhalt des Arrays modifizieren und dann eine neue Zeichenfolge aus dem modifizierten Inhalt des Arrays erstellen.

In folgendem Beispiel wird gezeigt, wie Sie mehrere Zeichen in einer Zeichenfolge ersetzen. Zunächst wird die Methode String.ToCharArray() verwendet, um ein Zeichenarray zu erstellen. Die Methode IndexOf wird verwendet, um den Startindex des Worts „fox“ zu finden. Die folgenden drei Zeichen werden durch ein anderes Wort ersetzt. Zum Schluss wird eine neue Zeichenfolge aus dem aktualisierten Zeichenarray erstellt.

string phrase = "The quick brown fox jumps over the fence";
Console.WriteLine(phrase);

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

string updatedPhrase = new string(phraseAsChars);
Console.WriteLine(updatedPhrase);

Programmgesteuertes Erstellen von Zeichenfolgeninhalten

Da Zeichenfolgen unveränderlich sind, erzeugen die vorherigen Beispiele alle temporäre Zeichenfolgen oder -arrays. In Hochleistungsszenarien ist es möglicherweise wünschenswert, diese Heapzuordnungen zu vermeiden. .NET Core bietet die Methode String.Create, mit der Sie den Zeicheninhalt einer Zeichenfolge über einen Rückruf programmgesteuert füllen können, wobei die zwischengeschalteten temporären Zeichenfolgenzuordnungen vermieden werden.

// constructing a string from a char array, prefix it with some additional characters
char[] chars = { 'a', 'b', 'c', 'd', '\0' };
int length = chars.Length + 2;
string result = string.Create(length, chars, (Span<char> strContent, char[] charArray) =>
{
    strContent[0] = '0';
    strContent[1] = '1';
    for (int i = 0; i < charArray.Length; i++)
    {
        strContent[i + 2] = charArray[i];
    }
});

Console.WriteLine(result);

Sie können eine Zeichenfolge in einem festen Block mit unsicherem Code ändern. Es wird jedoch stark davon abgeraten, den Inhalt der Zeichenfolge nach deren Erstellung zu ändern. Dadurch können Abläufe auf unvorhersehbare Weise beeinträchtigt werden. Wenn jemand beispielsweise eine Zeichenfolge internalisiert, die den gleichen Inhalt wie Ihre hat, erhält er Ihre Kopie und erwartet nicht, dass Sie seine Zeichenfolge ändern.

Siehe auch

• Reguläre Ausdrücke in .NET
• Sprachelemente für reguläre Ausdrücke – Kurzübersicht