C# String Methods: Split, Replace, Contains, IndexOf, Trim, Join and More

System.String has dozens of methods. This page covers the ones that do most of the work in real code, with the options and the traps that matter. One rule applies to all of them: strings are immutable, so every method returns a new string (or a value) and leaves the original unchanged. s.Trim(); on its own line does nothing; write s = s.Trim();.

Split

Split breaks a string into a string[] at each separator:

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

Output:

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

Notice " blue": Split cuts exactly at the separator and keeps any spaces. Two options handle the common cleanups:

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

Output:

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

RemoveEmptyEntries drops parts of length zero but not parts that are only spaces (" " survived above). .NET 5 added StringSplitOptions.TrimEntries, and the two can be combined: tags.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) gives the clean result in one call. Passing null as the separator splits on any whitespace, which is the usual way to split text into words.

Splitting on a single char (Split(',')) needs no array. The overloads that take a char plus options, or a single string, exist from .NET Core 2.0 on; the array forms used above work everywhere, including .NET Framework and Unity.

Replace

Replace substitutes every occurrence of a character or substring:

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

Output:

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

The overload with a StringComparison argument is available on .NET Core 2.0 and later. On .NET Framework, case-insensitive replacement is done with Regex.Replace(text, Regex.Escape(find), replacement, RegexOptions.IgnoreCase). Replacing with "" is how you remove characters, and chaining several Replace calls is fine for a handful of substitutions.

Contains, IndexOf, StartsWith and EndsWith

These methods search. Contains answers yes or no; IndexOf and LastIndexOf return a position, or -1 when there is no match; StartsWith and EndsWith test the ends.

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

Output:

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

All of these are case-sensitive by default. Contains(string, StringComparison) exists on .NET Core 2.1 and later; the IndexOf(...) >= 0 form works on every version, which is why you see it in older code. IndexOfAny(new[] { ',', ';' }) finds the first of several characters.

A culture note: without a StringComparison, StartsWith, EndsWith, IndexOf(string) and CompareTo use culture-sensitive rules, while Contains, Replace and IndexOf(char) compare ordinally. Passing StringComparison.Ordinal or OrdinalIgnoreCase explicitly removes the ambiguity, and code analyzers recommend it.

Trim, TrimStart and TrimEnd

Trim removes whitespace (spaces, tabs, newlines) from both ends. TrimStart and TrimEnd remove from one end. Given characters, they remove those instead:

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

Output:

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

Trim only touches the ends; spaces inside the string are kept. TrimStart('0') on "000" returns an empty string, so parse number strings with int.Parse rather than stripping zeros by hand.

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

Output:

MAYA LOPEZ
maya lopez
MAYA LOPEZ
Coffee

ToUpper and ToLower follow the current culture, so in Turkish "i".ToUpper() is a dotted capital İ, not I. For identifiers, keys and file names use ToUpperInvariant and ToLowerInvariant. For comparing, use a StringComparison instead of converting case at all (see strings). To capitalize every word, CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text) exists, though it leaves words that are already all uppercase alone.

PadLeft and PadRight

Padding adds characters until the string reaches a total width. It is handy for fixed-width output and for zero-padding codes:

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

Output:

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

Interpolation alignment ({name,-10}) does the same job inline.

Join and Concat

string.Join puts a separator between the elements of any collection. string.Concat joins with no separator:

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

Output:

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

Join is the right way to build a delimited list: there is no trailing separator to remove, and it builds the result in one pass. It calls ToString() on each element, so it works with numbers and objects as well.

Reverse, Insert and Remove

There is no string.Reverse method that returns a string. The two usual approaches:

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

Output:

desserts
desserts
True
2026/Q3-09
Hello
HelloWorld

word.Reverse() alone returns an IEnumerable<char>, not a string; printing it shows a type name. Both methods reverse UTF-16 code units, which breaks characters made of two units (most emoji) and letters with combining accents.

Quick reference