Runnable C# Docs: Substring

Q: How does Substring work in C#?

s.Substring(start) returns the characters from index start to the end; s.Substring(start, length) returns length characters beginning at start. Indexes start at 0, and the second argument is a length, not an end index: "Hello".Substring(1, 3) is "ell". The original string is not changed.

Q: Why does Substring throw ArgumentOutOfRangeException?

Because start is negative or greater than the string's length, or start + length goes past the end. The most common cause is a length computed for a longer string, or an IndexOf result of -1 used as a start. Clamp the length with Math.Min(length, s.Length - start) and check IndexOf results before using them.

Q: How do I get the last n characters of a string in C#?

s.Substring(s.Length - n) returns the last n characters, provided n <= s.Length. To be safe for short strings, use s.Length <= n ? s : s.Substring(s.Length - n). In C# 8 and later you can also write s[^n..], which throws the same way when n is too large.

Q: How do I get the substring between two characters in C#?

Find both positions with IndexOf, then take the part between them: int start = s.IndexOf('(') + 1; int end = s.IndexOf(')', start); string inside = s.Substring(start, end - start);. Check that each IndexOf found something (not -1) before calling Substring. For complex patterns, a regular expression is clearer.

Q: Is Substring zero-based in C#?

Yes. The first character is at index 0 and the last at Length - 1. Substring(0, 3) returns the first three characters. Passing Length itself as the start is allowed and returns an empty string.

Substring returns a new string made of part of an existing one. It has two overloads:

s.Substring(startIndex): from startIndex to the end.
s.Substring(startIndex, length): length characters, starting at startIndex.

Indexes start at 0, and the second argument is a length, not an end position. That is the difference from JavaScript's substring(start, end) and Java's substring(begin, end), and the source of many off-by-some bugs when code is ported.

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

Output:

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

Like every string method, Substring does not modify the original; it returns a new string, so assign the result.

ArgumentOutOfRangeException and how to avoid it

Substring throws ArgumentOutOfRangeException when the requested range does not fit inside the string: a negative startIndex, a startIndex greater than Length, a negative length, or startIndex + length greater than Length. There is no silent truncation, unlike Python slices.

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

Output:

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

The usual guard is to clamp the length to what is left of the string with Math.Min:

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)}]");
    }
}

Output:

ffee
ea
[]
[]

Calling Substring on a null string throws NullReferenceException, not ArgumentOutOfRangeException, which is why the helper checks for null first.

First and last n characters

Taking a prefix or a suffix is the most common use of Substring. Both throw when the string is shorter than n, so production code checks the length:

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

Output:

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

When the first part of the string is what you want to drop, Substring(n) alone is enough: "#FF8800".Substring(1) is "FF8800". The related Remove(start, count) does the inverse of Substring: it returns the string with that range taken out.

Substring with IndexOf

Most real substrings are found, not counted. IndexOf returns the position of a character or string (or -1 if it is not there), and LastIndexOf searches from the end. Combine them with Substring to cut text around a separator:

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

Output:

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

The arithmetic follows one rule: to take the text between positions a and b (not including either), the start is a + 1 and the length is b - a - 1.

The danger is IndexOf returning -1. email.Substring(0, -1) throws, and worse, email.Substring(-1 + 1) silently returns the whole string. Always check:

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

Output:

shop.io
(none)

Split as an alternative

When a string is a list of fields with a separator, Split is simpler than a chain of IndexOf and Substring calls, and it has no index arithmetic to get wrong:

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

Output:

Ana Silva
Porto
maya.lopez
beach.jpg

Split allocates an array plus one string per field, so for a single cut in a hot loop IndexOf and Substring are cheaper. For everything else, readability wins. More options (several separators, removing empty entries, a maximum count) are on string methods. For patterns such as "the digits after ID:", a regular expression is usually the clearest tool.

The range operator (C# 8 and later)

C# 8 added index and range syntax, which works on strings and arrays. ^n means "n from the end" and a..b is the range from a up to but not including b, so the second number is an end index, not a length:

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

On a string, a range compiles to a Substring call, so it allocates a new string and throws ArgumentOutOfRangeException for the same out-of-bounds cases. Which to use is style; ranges read better when both ends are measured from different sides ([1..^1]).

Substrings without copying: Span

Every Substring call allocates a new string. In performance-sensitive parsing code (reading large files, handling many requests), .NET Core 2.1 and later offer ReadOnlySpan<char>, a view into part of the original string with no copy:

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 cannot be stored in fields of ordinary classes or used across await, so they belong in tight, synchronous code. For typical application code, Substring is the right tool.

Common mistakes

Passing an end index as the length. s.Substring(2, 5) means five characters from index 2, not "index 2 to 5". To take the text from index a up to but not including index b, the length is b - a.
Not checking IndexOf for -1. Either an exception or, with + 1, the whole string by accident.
Assuming short strings are long enough. A name, code or line from a file can be shorter than you expect. Clamp with Math.Min or check Length.
Discarding the result. s.Substring(1); on its own line does nothing useful.

Frequently Asked Questions

How does Substring work in C#?

s.Substring(start) returns the characters from index start to the end; s.Substring(start, length) returns length characters beginning at start. Indexes start at 0, and the second argument is a length, not an end index: "Hello".Substring(1, 3) is "ell". The original string is not changed.

Why does Substring throw ArgumentOutOfRangeException?

Because start is negative or greater than the string's length, or start + length goes past the end. The most common cause is a length computed for a longer string, or an IndexOf result of -1 used as a start. Clamp the length with Math.Min(length, s.Length - start) and check IndexOf results before using them.

How do I get the last n characters of a string in C#?

s.Substring(s.Length - n) returns the last n characters, provided n <= s.Length. To be safe for short strings, use s.Length <= n ? s : s.Substring(s.Length - n). In C# 8 and later you can also write s[^n..], which throws the same way when n is too large.

How do I get the substring between two characters in C#?

Find both positions with IndexOf, then take the part between them: int start = s.IndexOf('(') + 1; int end = s.IndexOf(')', start); string inside = s.Substring(start, end - start);. Check that each IndexOf found something (not -1) before calling Substring. For complex patterns, a regular expression is clearer.

Is Substring zero-based in C#?

Yes. The first character is at index 0 and the last at Length - 1. Substring(0, 3) returns the first three characters. Passing Length itself as the start is allowed and returns an empty string.

Related concepts