Ausführbare C#-Docs: Substring

Q: Wie funktioniert Substring in C#?

s.Substring(start) gibt die Zeichen ab Index start bis zum Ende zurück; s.Substring(start, length) gibt length Zeichen ab start zurück. Indizes beginnen bei 0, und das zweite Argument ist eine Länge, kein Endindex: "Hello".Substring(1, 3) ist "ell". Der ursprüngliche String wird nicht verändert.

Q: Warum wirft Substring eine ArgumentOutOfRangeException?

Weil start negativ oder größer als die Länge des Strings ist oder start + length über das Ende hinausgeht. Die häufigste Ursache ist eine Länge, die für einen längeren String berechnet wurde, oder ein IndexOf-Ergebnis von -1, das als Start verwendet wird. Begrenze die Länge mit Math.Min(length, s.Length - start) und prüfe IndexOf-Ergebnisse, bevor du sie verwendest.

Q: Wie bekomme ich in C# die letzten n Zeichen eines Strings?

s.Substring(s.Length - n) gibt die letzten n Zeichen zurück, sofern n <= s.Length gilt. Sicher auch für kurze Strings ist s.Length <= n ? s : s.Substring(s.Length - n). Ab C# 8 kannst du auch s[^n..] schreiben, das auf dieselbe Weise wirft, wenn n zu groß ist.

Q: Wie bekomme ich in C# den Teilstring zwischen zwei Zeichen?

Finde beide Positionen mit IndexOf und nimm dann den Teil dazwischen: int start = s.IndexOf('(') + 1; int end = s.IndexOf(')', start); string inside = s.Substring(start, end - start);. Prüfe, ob jedes IndexOf etwas gefunden hat (nicht -1), bevor du Substring aufrufst. Für komplexe Muster ist ein regulärer Ausdruck klarer.

Q: Ist Substring in C# nullbasiert?

Ja. Das erste Zeichen steht an Index 0, das letzte an Length - 1. Substring(0, 3) gibt die ersten drei Zeichen zurück. Length selbst als Start zu übergeben ist erlaubt und liefert einen leeren String.

Substring gibt einen neuen String zurück, der aus einem Teil eines bestehenden besteht. Es gibt zwei Überladungen:

s.Substring(startIndex): von startIndex bis zum Ende.
s.Substring(startIndex, length): length Zeichen, beginnend bei startIndex.

Indizes beginnen bei 0, und das zweite Argument ist eine Länge, keine Endposition. Das ist der Unterschied zu substring(start, end) in JavaScript und substring(begin, end) in Java und die Quelle vieler Fehler um ein paar Stellen, wenn Code portiert wird.

using System;

class Program
{
    static void Main()
    {
        string sku = "SHOE-4271-BLK";
        //            0123456789...

        Console.WriteLine(sku.Substring(5));        // from index 5 to the end
        Console.WriteLine(sku.Substring(0, 4));     // 4 chars from index 0
        Console.WriteLine(sku.Substring(5, 4));     // 4 chars from index 5
        Console.WriteLine(sku.Substring(10, 3));    // last 3
        Console.WriteLine(sku.Substring(sku.Length).Length); // start == Length: empty string

        Console.WriteLine(sku);                     // unchanged: strings are immutable
    }
}

Ausgabe:

4271-BLK
SHOE
4271
BLK
0
SHOE-4271-BLK

Wie jede String-Methode verändert Substring das Original nicht; es gibt einen neuen String zurück, also weise das Ergebnis zu.

ArgumentOutOfRangeException und wie du sie vermeidest

Substring wirft ArgumentOutOfRangeException, wenn der angeforderte Bereich nicht in den String passt: ein negativer startIndex, ein startIndex größer als Length, eine negative length oder startIndex + length größer als Length. Anders als bei Python-Slices wird nicht stillschweigend gekürzt.

using System;

class Program
{
    static void Show(string label, Func<string> take)
    {
        try
        {
            Console.WriteLine($"{label} -> \"{take()}\"");
        }
        catch (ArgumentOutOfRangeException)
        {
            Console.WriteLine($"{label} -> ArgumentOutOfRangeException");
        }
    }

    static void Main()
    {
        string word = "Coffee";   // Length 6

        Show("Substring(2, 4)", () => word.Substring(2, 4));
        Show("Substring(2, 5)", () => word.Substring(2, 5));   // 2 + 5 > 6
        Show("Substring(6)", () => word.Substring(6));         // allowed: empty
        Show("Substring(7)", () => word.Substring(7));
        Show("Substring(-1)", () => word.Substring(-1));
        Show("Substring(0, 10)", () => word.Substring(0, 10));
    }
}

Ausgabe:

Substring(2, 4) -> "ffee"
Substring(2, 5) -> ArgumentOutOfRangeException
Substring(6) -> ""
Substring(7) -> ArgumentOutOfRangeException
Substring(-1) -> ArgumentOutOfRangeException
Substring(0, 10) -> ArgumentOutOfRangeException

Die übliche Absicherung ist, die Länge mit Math.Min auf den Rest des Strings zu begrenzen:

using System;

class Program
{
    static string SafeSubstring(string s, int start, int length)
    {
        if (string.IsNullOrEmpty(s) || start >= s.Length) return "";
        if (start < 0) start = 0;
        return s.Substring(start, Math.Min(length, s.Length - start));
    }

    static void Main()
    {
        Console.WriteLine(SafeSubstring("Coffee", 2, 100));
        Console.WriteLine(SafeSubstring("Tea", 1, 2));
        Console.WriteLine($"[{SafeSubstring("Tea", 5, 2)}]");
        Console.WriteLine($"[{SafeSubstring(null, 0, 2)}]");
    }
}

Ausgabe:

ffee
ea
[]
[]

Substring auf einem null-String aufzurufen wirft NullReferenceException, nicht ArgumentOutOfRangeException. Deshalb prüft die Hilfsmethode zuerst auf null.

Erste und letzte n Zeichen

Ein Präfix oder Suffix zu nehmen ist die häufigste Verwendung von Substring. Beide Varianten werfen, wenn der String kürzer als n ist, daher prüft Produktionscode die Länge:

using System;

class Program
{
    static string Left(string s, int n) => s.Length <= n ? s : s.Substring(0, n);
    static string Right(string s, int n) => s.Length <= n ? s : s.Substring(s.Length - n);

    static void Main()
    {
        string card = "4111111111111111";
        Console.WriteLine("**** " + Right(card, 4));

        string title = "An Unexpectedly Long Product Name";
        Console.WriteLine(Left(title, 12) + "...");

        Console.WriteLine(Left("Hi", 12));     // shorter than n: returned whole
        Console.WriteLine(Right("Hi", 4));
    }
}

Ausgabe:

**** 1111
An Unexpecte...
Hi
Hi

Wenn du den Anfang des Strings loswerden willst, reicht Substring(n) allein: "#FF8800".Substring(1) ist "FF8800". Das verwandte Remove(start, count) macht das Gegenteil von Substring: Es gibt den String ohne diesen Bereich zurück.

Substring mit IndexOf

Die meisten echten Teilstrings werden gesucht, nicht abgezählt. IndexOf gibt die Position eines Zeichens oder Strings zurück (oder -1, wenn er nicht vorkommt), und LastIndexOf sucht vom Ende her. Kombiniere sie mit Substring, um Text an einem Trennzeichen zu zerschneiden:

using System;

class Program
{
    static void Main()
    {
        string email = "maya.lopez@example.com";
        int at = email.IndexOf('@');
        Console.WriteLine(email.Substring(0, at));       // before the @
        Console.WriteLine(email.Substring(at + 1));      // after the @

        string file = "report.final.v2.pdf";
        int dot = file.LastIndexOf('.');
        Console.WriteLine(file.Substring(dot + 1));      // extension
        Console.WriteLine(file.Substring(0, dot));       // name without extension

        string log = "2026-09-24 [WARN] Disk almost full";
        int open = log.IndexOf('[');
        int close = log.IndexOf(']', open + 1);
        Console.WriteLine(log.Substring(open + 1, close - open - 1)); // between [ and ]
        Console.WriteLine(log.Substring(close + 2));                  // the message
    }
}

Ausgabe:

maya.lopez
example.com
pdf
report.final.v2
WARN
Disk almost full

Die Arithmetik folgt einer Regel: Um den Text zwischen den Positionen a und b zu nehmen (beide ausgeschlossen), ist der Start a + 1 und die Länge b - a - 1.

Die Gefahr ist, dass IndexOf -1 zurückgibt. email.Substring(0, -1) wirft, und schlimmer noch, email.Substring(-1 + 1) gibt stillschweigend den ganzen String zurück. Prüfe immer:

using System;

class Program
{
    static string Domain(string email)
    {
        int at = email.IndexOf('@');
        if (at < 0) return null;
        return email.Substring(at + 1);
    }

    static void Main()
    {
        Console.WriteLine(Domain("leo@shop.io") ?? "(none)");
        Console.WriteLine(Domain("not-an-email") ?? "(none)");
    }
}

Ausgabe:

shop.io
(none)

Split als Alternative

Wenn ein String eine Liste von Feldern mit Trennzeichen ist, ist Split einfacher als eine Kette von Aufrufen von IndexOf und Substring, und es gibt keine Indexarithmetik, bei der man sich vertun kann:

using System;

class Program
{
    static void Main()
    {
        string row = "1042;Ana Silva;Porto;31";
        string[] fields = row.Split(';');
        Console.WriteLine(fields[1]);
        Console.WriteLine(fields[2]);

        string email = "maya.lopez@example.com";
        string user = email.Split('@')[0];
        Console.WriteLine(user);

        string path = "images/2026/09/beach.jpg";
        string[] parts = path.Split('/');
        Console.WriteLine(parts[parts.Length - 1]);   // last segment
    }
}

Ausgabe:

Ana Silva
Porto
maya.lopez
beach.jpg

Split allokiert ein Array plus einen String pro Feld. Für einen einzelnen Schnitt in einer heißen Schleife sind IndexOf und Substring daher günstiger. Überall sonst gewinnt die Lesbarkeit. Weitere Optionen (mehrere Trennzeichen, leere Einträge entfernen, eine Höchstanzahl) findest du unter String-Methoden. Für Muster wie „die Ziffern nach ID:“ ist ein regulärer Ausdruck meist das klarste Werkzeug.

Der Bereichsoperator (ab C# 8)

C# 8 hat Index- und Bereichssyntax eingeführt, die mit Strings und Arrays funktioniert. ^n bedeutet „n vom Ende“, und a..b ist der Bereich von a bis ausschließlich b, die zweite Zahl ist also ein Endindex, keine Länge:

// C# 8 and later
string sku = "SHOE-4271-BLK";

string first4 = sku[..4];      // "SHOE"        same as Substring(0, 4)
string middle = sku[5..9];     // "4271"        same as Substring(5, 4)
string last3  = sku[^3..];     // "BLK"         same as Substring(sku.Length - 3)
string noEnds = sku[1..^1];    // "HOE-4271-BL" drop first and last
char lastChar = sku[^1];       // 'K'

Bei einem String wird ein Bereich zu einem Aufruf von Substring kompiliert, er allokiert also einen neuen String und wirft ArgumentOutOfRangeException in denselben Fällen außerhalb der Grenzen. Was du nimmst, ist Stilfrage; Bereiche lesen sich besser, wenn beide Enden von verschiedenen Seiten gemessen werden ([1..^1]).

Teilstrings ohne Kopie: Span

Jeder Aufruf von Substring allokiert einen neuen String. In performancekritischem Parsing-Code (große Dateien lesen, viele Anfragen verarbeiten) bieten .NET Core 2.1 und neuer ReadOnlySpan<char>, eine Sicht auf einen Teil des ursprünglichen Strings ohne Kopie:

ReadOnlySpan<char> line = "2026-09-24,42.50,EUR".AsSpan();
ReadOnlySpan<char> amount = line.Slice(11, 5);          // "42.50", no allocation
decimal value = decimal.Parse(amount, provider: CultureInfo.InvariantCulture);

Spans können nicht in Feldern normaler Klassen gespeichert oder über await hinweg verwendet werden, sie gehören also in engen, synchronen Code. Für typischen Anwendungscode ist Substring das richtige Werkzeug.

Häufige Fehler

Einen Endindex als Länge übergeben. s.Substring(2, 5) bedeutet fünf Zeichen ab Index 2, nicht „Index 2 bis 5“. Um den Text von Index a bis ausschließlich Index b zu nehmen, ist die Länge b - a.
IndexOf nicht auf -1 prüfen. Entweder eine Exception oder, mit + 1, versehentlich der ganze String.
Annehmen, dass kurze Strings lang genug sind. Ein Name, ein Code oder eine Zeile aus einer Datei kann kürzer sein als erwartet. Begrenze mit Math.Min oder prüfe Length.
Das Ergebnis verwerfen. s.Substring(1); allein in einer Zeile bewirkt nichts Nützliches.

Häufig gestellte Fragen

Wie funktioniert Substring in C#?

s.Substring(start) gibt die Zeichen ab Index start bis zum Ende zurück; s.Substring(start, length) gibt length Zeichen ab start zurück. Indizes beginnen bei 0, und das zweite Argument ist eine Länge, kein Endindex: "Hello".Substring(1, 3) ist "ell". Der ursprüngliche String wird nicht verändert.

Warum wirft Substring eine ArgumentOutOfRangeException?

Weil start negativ oder größer als die Länge des Strings ist oder start + length über das Ende hinausgeht. Die häufigste Ursache ist eine Länge, die für einen längeren String berechnet wurde, oder ein IndexOf-Ergebnis von -1, das als Start verwendet wird. Begrenze die Länge mit Math.Min(length, s.Length - start) und prüfe IndexOf-Ergebnisse, bevor du sie verwendest.

Wie bekomme ich in C# die letzten n Zeichen eines Strings?

s.Substring(s.Length - n) gibt die letzten n Zeichen zurück, sofern n <= s.Length gilt. Sicher auch für kurze Strings ist s.Length <= n ? s : s.Substring(s.Length - n). Ab C# 8 kannst du auch s[^n..] schreiben, das auf dieselbe Weise wirft, wenn n zu groß ist.

Wie bekomme ich in C# den Teilstring zwischen zwei Zeichen?

Finde beide Positionen mit IndexOf und nimm dann den Teil dazwischen: int start = s.IndexOf('(') + 1; int end = s.IndexOf(')', start); string inside = s.Substring(start, end - start);. Prüfe, ob jedes IndexOf etwas gefunden hat (nicht -1), bevor du Substring aufrufst. Für komplexe Muster ist ein regulärer Ausdruck klarer.

Ist Substring in C# nullbasiert?

Ja. Das erste Zeichen steht an Index 0, das letzte an Length - 1. Substring(0, 3) gibt die ersten drei Zeichen zurück. Length selbst als Start zu übergeben ist erlaubt und liefert einen leeren String.

Verwandte Konzepte