Как посчитать количество вхождений символа или подстроки в строку на C#: 5 способов

Сколько раз буква «а» встречается в слове «абракадабра»? Решаем задачу на C#

Представьте: вы пишете анализатор логов, парсите CSV-файл или просто проверяете, сколько раз пользователь ввёл символ @ в email. Задача «посчитать количество вхождений символа или подстроки в строку» — одна из тех, что встречается в каждом втором проекте. На Stack Overflow этот вопрос собрал тысячи просмотров и десятки вариантов ответов. Неудивительно: в C# есть как минимум 5 разных способов, и выбор правильного может сэкономить часы отладки.

В этой статье мы разберём все популярные методы — от классического цикла до современных Span<T> и LINQ. Вы узнаете, какой способ быстрее, какой читаемее, а какой лучше не использовать в продакшене. Поехали!

1. Классический цикл foreach — дедушкин метод

Самый интуитивный способ: берём строку, проходим по каждому символу и считаем совпадения. Работает всегда, не требует дополнительных библиотек.

string text = "абракадабра";
char target = 'а';
int count = 0;

foreach (char c in text)
{
    if (c == target)
        count++;
}

Console.WriteLine($"Символ '{target}' встречается {count} раз(а)."); // Вывод: 4

Плюсы: читаемость, контроль над процессом, можно добавить логику (например, игнорировать регистр).
Минусы: не подходит для подсчёта подстрок (несколько символов подряд) — для этого придётся писать вложенный цикл.

2. Метод Count() из LINQ — однострочник для символов

Если вы любите лаконичный код и используете LINQ, этот вариант для вас. Метод Count() принимает предикат и возвращает количество элементов, удовлетворяющих условию.

using System.Linq;

string text = "Hello, World!";
char target = 'l';

int count = text.Count(c => c == target);
Console.WriteLine(count); // Вывод: 3

Обратите внимание: Count() — это метод расширения из пространства имён System.Linq. Если вы не подключили using System.Linq, код не скомпилируется.

Для подсчёта подстроки этот метод не подходит напрямую. Придётся сначала разбить строку или использовать регулярные выражения (см. п.5).

3. Span<T> и MemoryExtensions — производительность на максимум

Если вы работаете с большими строками (мегабайты логов) и каждая миллисекунда на счету, забудьте про LINQ. Используйте Span<char> и метод Count() из MemoryExtensions (доступен с .NET 5+).

using System;

string text = "абракадабра";
ReadOnlySpan<char> span = text.AsSpan();
int count = span.Count('а');

Console.WriteLine(count); // Вывод: 4

Почему это быстро? Span<T> работает с непрерывными блоками памяти без выделения новых объектов. Метод Count() в MemoryExtensions оптимизирован под SIMD-инструкции — он обрабатывает по 16-32 символа за один такт процессора.

Для подстрок тоже есть решение:

int count = span.Count("ра"); // считает вхождения подстроки "ра"
Console.WriteLine(count); // Вывод: 2 ("абракадабра" содержит "ра" дважды)

Важно: этот метод чувствителен к регистру. Если нужно игнорировать регистр, сначала приведите строку к одному регистру или используйте span.Count("ра", StringComparison.OrdinalIgnoreCase).

4. Split-метод — хитрый трюк для подстрок

Старый, но рабочий способ: разбить строку по искомой подстроке и посчитать количество частей минус один.

string text = "один, два, три, один, четыре";
string target = "один";

int count = text.Split(target, StringSplitOptions.None).Length - 1;
Console.WriteLine(count); // Вывод: 2

Как это работает: Split разделяет строку на массив подстрок. Если подстрока встречается n раз, то элементов массива будет n+1. Вычитаем единицу — получаем количество вхождений.

Подводные камни:

• Метод создаёт новый массив и новые строки — это дорого по памяти.
• Если подстрока находится в начале или конце строки, Split может создать пустые строки (их можно отфильтровать флагом StringSplitOptions.RemoveEmptyEntries).
• Не используйте этот метод для больших данных — производительность упадёт.

5. Регулярные выражения — гибкость и мощь

Когда нужно считать вхождения сложного шаблона (например, все гласные буквы или номера телефонов), на помощь приходит Regex.

using System.Text.RegularExpressions;

string text = "C# 8.0, C# 9.0, C# 10.0";
string pattern = @"C# \d+\.\d+";

int count = Regex.Matches(text, pattern).Count;
Console.WriteLine(count); // Вывод: 3

Для простого символа или подстроки регулярки — это избыточно. Но если шаблон сложный, без них не обойтись.

Совет: если вы используете один и тот же шаблон много раз, создайте статический объект Regex с флагом RegexOptions.Compiled — это ускорит работу в 2-3 раза.

Сравнение производительности: что выбрать?

Я прогнал тесты на случайной строке длиной 1 миллион символов (искомая подстрока — 3 символа). Вот результаты (время в миллисекундах, меньше — лучше):

Выводы:

• Для одного символа — Span.Count() или foreach (если нужна гибкость).
• Для подстроки — Span.Count() или Regex (если шаблон сложный).
• Split используйте только для коротких строк или если код пишется «на коленке».
• LINQ