Методы строк в C#: Split, Replace, Contains, IndexOf, Trim, Join и другие

У System.String десятки методов. На этой странице описаны те, что выполняют большую часть работы в реальном коде, с важными опциями и ловушками. Для всех них действует одно правило: строки неизменяемы, поэтому каждый метод возвращает новую строку (или значение) и не меняет исходную. s.Trim(); в отдельной строке ничего не делает; пишите s = s.Trim();.

Split

Split разбивает строку на 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));
    }
}

Вывод:

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

Обратите внимание на " blue": Split режет точно по разделителю и сохраняет пробелы. Две опции решают частые задачи очистки:

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

Вывод:

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

RemoveEmptyEntries убирает части нулевой длины, но не части, состоящие только из пробелов (" " выше уцелела). .NET 5 добавил StringSplitOptions.TrimEntries, и эти опции можно сочетать: tags.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries) даёт чистый результат одним вызовом. Если передать null в качестве разделителя, строка разделится по любым пробельным символам; это обычный способ разбить текст на слова.

Для разделения по одному char (Split(',')) массив не нужен. Перегрузки, которые принимают char вместе с опциями или одну string, есть начиная с .NET Core 2.0; формы с массивом, использованные выше, работают везде, включая .NET Framework и Unity.

Replace

Replace заменяет каждое вхождение символа или подстроки:

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

Вывод:

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

Перегрузка с аргументом StringComparison доступна в .NET Core 2.0 и новее. В .NET Framework замена без учёта регистра выполняется через Regex.Replace(text, Regex.Escape(find), replacement, RegexOptions.IgnoreCase). Замена на "" это способ удалить символы, а цепочка из нескольких вызовов Replace вполне годится для нескольких подстановок.

Contains, IndexOf, StartsWith и EndsWith

Эти методы выполняют поиск. Contains отвечает да или нет; IndexOf и LastIndexOf возвращают позицию или -1, если совпадения нет; StartsWith и EndsWith проверяют концы строки.

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

Вывод:

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

Все они по умолчанию учитывают регистр. Contains(string, StringComparison) есть в .NET Core 2.1 и новее; форма IndexOf(...) >= 0 работает в любой версии, поэтому она встречается в старом коде. IndexOfAny(new[] { ',', ';' }) находит первый из нескольких символов.

Замечание о культуре: без StringComparison методы StartsWith, EndsWith, IndexOf(string) и CompareTo используют правила с учётом культуры, а Contains, Replace и IndexOf(char) сравнивают порядково. Явная передача StringComparison.Ordinal или OrdinalIgnoreCase убирает неоднозначность, и анализаторы кода это рекомендуют.

Trim, TrimStart и TrimEnd

Trim удаляет пробельные символы (пробелы, табуляции, переводы строк) с обоих концов. TrimStart и TrimEnd удаляют с одного конца. Если передать символы, удаляются они:

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

Вывод:

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

Trim затрагивает только концы; пробелы внутри строки сохраняются. TrimStart('0') для "000" возвращает пустую строку, поэтому строки с числами разбирайте через int.Parse, а не убирайте нули вручную.

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

Вывод:

MAYA LOPEZ
maya lopez
MAYA LOPEZ
Coffee

ToUpper и ToLower следуют текущей культуре, поэтому в турецкой культуре "i".ToUpper() даёт заглавную İ с точкой, а не I. Для идентификаторов, ключей и имён файлов используйте ToUpperInvariant и ToLowerInvariant. Для сравнения используйте StringComparison вместо изменения регистра (см. строки). Чтобы сделать каждое слово с заглавной буквы, есть CultureInfo.CurrentCulture.TextInfo.ToTitleCase(text), хотя он не трогает слова, которые уже целиком написаны заглавными.

PadLeft и PadRight

Дополнение добавляет символы, пока строка не достигнет заданной общей ширины. Это удобно для вывода фиксированной ширины и для дополнения кодов нулями:

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

Вывод:

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

Выравнивание в интерполяции ({name,-10}) делает то же самое прямо в строке.

Join и Concat

string.Join ставит разделитель между элементами любой коллекции. string.Concat соединяет без разделителя:

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

Вывод:

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

Join это правильный способ собрать список с разделителями: не остаётся лишнего разделителя в конце, который нужно удалять, и результат строится за один проход. Он вызывает ToString() у каждого элемента, поэтому работает и с числами, и с объектами.

Reverse, Insert и Remove

Метода string.Reverse, возвращающего строку, нет. Два обычных подхода:

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

Вывод:

desserts
desserts
True
2026/Q3-09
Hello
HelloWorld

word.Reverse() сам по себе возвращает IEnumerable<char>, а не строку; при выводе вы увидите имя типа. Оба способа переворачивают кодовые единицы UTF-16, что ломает символы из двух единиц (большинство эмодзи) и буквы с комбинируемыми диакритическими знаками.

Краткая справка