C# String-Methoden: Split, Replace, Contains, IndexOf, Trim, Join und mehr

System.String hat Dutzende Methoden. Diese Seite behandelt die, die in echtem Code die meiste Arbeit erledigen, mit den Optionen und Fallen, die zählen. Eine Regel gilt für alle: Strings sind unveränderlich, jede Methode gibt also einen neuen String (oder einen Wert) zurück und lässt das Original unverändert. s.Trim(); allein in einer Zeile bewirkt nichts; schreibe s = s.Trim();.

Split

Split zerlegt einen String an jedem Trennzeichen in ein string[]:

using System;

class Program
{
    static void Main()
    {
        string csv = "apple,banana,cherry";
        string[] fruits = csv.Split(',');
        Console.WriteLine(fruits.Length);
        foreach (string f in fruits) Console.WriteLine(f);

        // Several separator characters
        string messy = "red;green, blue|yellow";
        string[] colors = messy.Split(new[] { ';', ',', '|' });
        Console.WriteLine(string.Join("/", colors));

        // A separator longer than one character
        string log = "INFO -> started -> ready";
        string[] steps = log.Split(new[] { " -> " }, StringSplitOptions.None);
        Console.WriteLine(string.Join("/", steps));
    }
}

Ausgabe:

3
apple
banana
cherry
red/green/ blue/yellow
INFO/started/ready

Beachte " blue": Split schneidet genau am Trennzeichen und behält alle Leerzeichen. Zwei Optionen erledigen das übliche Aufräumen:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string tags = "c#, ,dotnet,,  linq ";

        string[] raw = tags.Split(',');
        Console.WriteLine(raw.Length);   // empty and blank parts included

        string[] noEmpty = tags.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
        Console.WriteLine(noEmpty.Length);

        string[] clean = tags.Split(',')
            .Select(t => t.Trim())
            .Where(t => t.Length > 0)
            .ToArray();
        Console.WriteLine(string.Join("|", clean));

        // Limit the number of parts: the last one keeps the rest
        string header = "Subject: Re: Meeting: Friday";
        string[] kv = header.Split(new[] { ':' }, 2);
        Console.WriteLine($"key=[{kv[0]}] value=[{kv[1].Trim()}]");

        string words = "one  two   three";
        Console.WriteLine(words.Split((char[])null, StringSplitOptions.RemoveEmptyEntries).Length); // split on any whitespace
    }
}

Ausgabe:

5
4
c#|dotnet|linq
key=[Subject] value=[Re: Meeting: Friday]
3

RemoveEmptyEntries verwirft Teile der Länge null, aber keine Teile, die nur aus Leerzeichen bestehen (" " hat oben überlebt). .NET 5 hat StringSplitOptions.TrimEntries hinzugefügt, und beide lassen sich kombinieren: tags.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) liefert das saubere Ergebnis in einem Aufruf. Übergibst du null als Trennzeichen, wird an jedem Leerraum geteilt, der übliche Weg, Text in Wörter zu zerlegen.

Das Teilen an einem einzelnen char (Split(',')) braucht kein Array. Die Überladungen, die ein char plus Optionen oder einen einzelnen string nehmen, gibt es ab .NET Core 2.0; die oben verwendeten Array-Formen funktionieren überall, auch unter .NET Framework und in Unity.

Replace

Replace ersetzt jedes Vorkommen eines Zeichens oder Teilstrings:

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        string phone = "555-123-4567";
        Console.WriteLine(phone.Replace("-", ""));       // remove
        Console.WriteLine(phone.Replace('-', '.'));      // char overload

        string text = "Cats and cats and CATS";
        Console.WriteLine(text.Replace("cats", "dogs")); // case-sensitive
        Console.WriteLine(text.Replace("cats", "dogs", StringComparison.OrdinalIgnoreCase));

        // Only the first occurrence
        var first = new Regex("cats", RegexOptions.IgnoreCase);
        Console.WriteLine(first.Replace(text, "dogs", 1));

        // Collapse repeated spaces
        Console.WriteLine(Regex.Replace("too    many   spaces", @"\s+", " "));
    }
}

Ausgabe:

5551234567
555.123.4567
Cats and dogs and CATS
dogs and dogs and dogs
dogs and cats and CATS
too many spaces

Die Überladung mit einem StringComparison-Argument gibt es ab .NET Core 2.0. Unter .NET Framework erledigt man das Ersetzen ohne Groß- und Kleinschreibung mit Regex.Replace(text, Regex.Escape(find), replacement, RegexOptions.IgnoreCase). Durch Ersetzen mit "" entfernst du Zeichen, und mehrere verkettete Replace-Aufrufe sind für eine Handvoll Ersetzungen in Ordnung.

Contains, IndexOf, StartsWith und EndsWith

Diese Methoden suchen. Contains antwortet mit Ja oder Nein; IndexOf und LastIndexOf geben eine Position zurück oder -1, wenn es keinen Treffer gibt; StartsWith und EndsWith prüfen die Enden.

using System;

class Program
{
    static void Main()
    {
        string subject = "Invoice #4471 overdue: please pay";

        Console.WriteLine(subject.Contains("overdue"));                    // True
        Console.WriteLine(subject.Contains("OVERDUE"));                    // False: case-sensitive
        Console.WriteLine(subject.Contains("OVERDUE", StringComparison.OrdinalIgnoreCase));
        Console.WriteLine(subject.IndexOf("OVERDUE", StringComparison.OrdinalIgnoreCase) >= 0);

        Console.WriteLine(subject.IndexOf('#'));            // 8
        Console.WriteLine(subject.IndexOf("pay"));          // first "pay"
        Console.WriteLine(subject.LastIndexOf('e'));
        Console.WriteLine(subject.IndexOf("refund"));       // -1: not found
        Console.WriteLine(subject.IndexOf('e', 10));        // search from index 10

        string file = "photo.JPG";
        Console.WriteLine(file.EndsWith(".jpg"));           // False
        Console.WriteLine(file.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase));
        Console.WriteLine("https://coddy.tech".StartsWith("https://"));
    }
}

Ausgabe:

True
False
True
True
8
30
28
-1
16
False
True
True

Alle beachten standardmäßig Groß- und Kleinschreibung. Contains(string, StringComparison) gibt es ab .NET Core 2.1; die Form IndexOf(...) >= 0 funktioniert in jeder Version, deshalb begegnet sie dir in älterem Code. IndexOfAny(new[] { ',', ';' }) findet das erste von mehreren Zeichen.

Ein Hinweis zur Kultur: Ohne StringComparison verwenden StartsWith, EndsWith, IndexOf(string) und CompareTo kulturabhängige Regeln, während Contains, Replace und IndexOf(char) ordinal vergleichen. Wer StringComparison.Ordinal oder OrdinalIgnoreCase explizit übergibt, beseitigt die Mehrdeutigkeit, und Code-Analyzer empfehlen genau das.

Trim, TrimStart und TrimEnd

Trim entfernt Leerraum (Leerzeichen, Tabs, Zeilenumbrüche) an beiden Enden. TrimStart und TrimEnd entfernen an einem Ende. Bekommen sie Zeichen übergeben, entfernen sie stattdessen diese:

using System;

class Program
{
    static void Main()
    {
        string input = "  \t ana@example.com \n";
        Console.WriteLine($"[{input.Trim()}]");
        Console.WriteLine($"[{input.TrimStart()}]".Replace("\n", "\\n"));
        Console.WriteLine($"[{"  x  ".TrimEnd()}]");

        Console.WriteLine("***SALE***".Trim('*'));
        Console.WriteLine("007".TrimStart('0'));
        Console.WriteLine("path/to/dir///".TrimEnd('/'));
        Console.WriteLine("1,234.50 USD".TrimEnd(' ', 'U', 'S', 'D'));
    }
}

Ausgabe:

[ana@example.com]
[ana@example.com \n]
[  x]
SALE
7
path/to/dir
1,234.50

Trim bearbeitet nur die Enden; Leerzeichen im Inneren des Strings bleiben erhalten. TrimStart('0') auf "000" gibt einen leeren String zurück, parse Zahlenstrings also mit int.Parse, statt Nullen von Hand zu entfernen.

ToUpper und ToLower

using System;

class Program
{
    static void Main()
    {
        string name = "maya Lopez";
        Console.WriteLine(name.ToUpper());
        Console.WriteLine(name.ToLower());
        Console.WriteLine(name.ToUpperInvariant());

        // Capitalize the first letter
        string word = "coffee";
        string capital = char.ToUpper(word[0]) + word.Substring(1);
        Console.WriteLine(capital);
    }
}

Ausgabe:

MAYA LOPEZ
maya lopez
MAYA LOPEZ
Coffee

ToUpper und ToLower folgen der aktuellen Kultur, im Türkischen ist "i".ToUpper() daher ein großes İ mit Punkt, nicht I. Für Bezeichner, Schlüssel und Dateinamen nimm ToUpperInvariant und ToLowerInvariant. Zum Vergleichen nimm eine StringComparison, statt die Schreibweise überhaupt umzuwandeln (siehe Strings). Um jedes Wort großzuschreiben, gibt es CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text), das allerdings Wörter unverändert lässt, die schon komplett großgeschrieben sind.

PadLeft und PadRight

Auffüllen fügt Zeichen hinzu, bis der String eine Gesamtbreite erreicht. Das ist praktisch für Ausgaben mit fester Breite und um Codes mit Nullen aufzufüllen:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("42".PadLeft(6, '0'));
        Console.WriteLine("[" + "Tea".PadRight(8) + "]");
        Console.WriteLine("[" + "Tea".PadLeft(8) + "]");
        Console.WriteLine("Too long already".PadLeft(4));   // never truncates

        string[] items = { "Espresso", "Latte", "Mocha" };
        decimal[] prices = { 2.40m, 3.60m, 3.95m };
        for (int i = 0; i < items.Length; i++)
        {
            Console.WriteLine(items[i].PadRight(10, '.') + prices[i].ToString("F2").PadLeft(6));
        }
    }
}

Ausgabe:

000042
[Tea     ]
[     Tea]
Too long already
Espresso..  2.40
Latte.....  3.60
Mocha.....  3.95

Die Ausrichtung bei der Interpolation ({name,-10}) erledigt dieselbe Aufgabe direkt im String.

Join und Concat

string.Join setzt ein Trennzeichen zwischen die Elemente einer beliebigen Collection. string.Concat verbindet ohne Trennzeichen:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var guests = new List<string> { "Ana", "Ben", "Chloe" };
        Console.WriteLine(string.Join(", ", guests));
        Console.WriteLine(string.Join(" + ", new[] { 1, 2, 3 }));   // any type
        Console.WriteLine(string.Join(",", new string[0]) == "");    // empty input: empty string

        Console.WriteLine(string.Concat("2026", "-", "09"));
        Console.WriteLine(string.Concat(guests));

        // "A, B and C"
        string list = guests.Count > 1
            ? string.Join(", ", guests.GetRange(0, guests.Count - 1)) + " and " + guests[guests.Count - 1]
            : string.Join("", guests);
        Console.WriteLine(list);
    }
}

Ausgabe:

Ana, Ben, Chloe
1 + 2 + 3
True
2026-09
AnaBenChloe
Ana, Ben and Chloe

Join ist der richtige Weg, eine Liste mit Trennzeichen zu bauen: Es gibt kein überzähliges Trennzeichen am Ende zu entfernen, und das Ergebnis entsteht in einem Durchgang. Es ruft für jedes Element ToString() auf und funktioniert daher auch mit Zahlen und Objekten.

Reverse, Insert und Remove

Es gibt keine Methode string.Reverse, die einen String zurückgibt. Die zwei üblichen Ansätze:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string word = "stressed";

        char[] chars = word.ToCharArray();
        Array.Reverse(chars);
        Console.WriteLine(new string(chars));

        Console.WriteLine(new string(word.Reverse().ToArray()));   // LINQ

        string racecar = "Racecar";
        string lower = racecar.ToLowerInvariant();
        Console.WriteLine(lower == new string(lower.Reverse().ToArray()));  // palindrome?

        Console.WriteLine("2026-09".Insert(4, "/Q3"));     // insert at an index
        Console.WriteLine("Hello, World".Remove(5));        // everything from index 5 removed
        Console.WriteLine("Hello, World".Remove(5, 2));     // 2 chars removed at 5
    }
}

Ausgabe:

desserts
desserts
True
2026/Q3-09
Hello
HelloWorld

word.Reverse() allein gibt ein IEnumerable<char> zurück, keinen String; die Ausgabe zeigt einen Typnamen. Beide Methoden kehren UTF-16-Codeeinheiten um, was Zeichen aus zwei Einheiten (die meisten Emojis) und Buchstaben mit kombinierenden Akzenten zerstört.

Kurzübersicht