Итераторы и генераторы в C# (.NET): подробное руководство

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты — библиотекарь, а перед тобой стоит огромный стеллаж с книгами. Твоя задача — переписать названия всех книг в каталог. У тебя есть два способа это сделать:

Способ 1 (жадный): Ты снимаешь с полки все книги сразу, складываешь их на свой стол, и только потом начинаешь переписывать. Если книг 10 000, твой стол будет завален, тебе негде будет работать, а если книг миллион — стол просто сломается под их весом.

Способ 2 (ленивый, но умный): Ты подходишь к стеллажу, смотришь на первую книгу, записываешь её название, затем переходишь ко второй, записываешь её — и так до конца. В каждый момент времени у тебя в руках только одна книга. Твой стол остаётся пустым, а память не перегружается.

В программировании итераторы — это и есть тот самый «умный библиотекарь». Они позволяют перебирать элементы коллекции (списка, массива, базы данных) по одному, не загружая все данные в память сразу. А генераторы — это особый вид итераторов, которые умеют не только перебирать готовые данные, но и создавать их на лету, прямо во время перебора.

💡 Важно: Итераторы и генераторы — это не магия, а всего лишь удобный шаблон проектирования, который встроен прямо в язык C#. Они помогают писать код, который работает быстро и не тратит лишнюю память.

Зачем это нужно в реальной жизни? Представь, что ты пишешь программу для чтения огромного лог-файла размером 10 гигабайт. Если ты загрузишь его целиком в память — программа упадёт с ошибкой OutOfMemoryException. Но если ты используешь итератор, ты сможешь читать файл построчно, обрабатывая каждую строку по мере поступления. Память будет занята всего на несколько килобайт!

Или другой пример: тебе нужно сгенерировать бесконечную последовательность чисел Фибоначчи. Обычный список не подойдёт — он не может быть бесконечным. А генератор — может! Он будет выдавать следующее число только тогда, когда ты его попросишь.

Теория: как это работает изнутри

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

Интерфейс IEnumerable — «обещание перебрать»

Представь, что это такой «сертификат», который говорит: «Я умею перебирать свои элементы». Любая коллекция, которую можно перебрать в цикле foreach (список, массив, словарь), реализует этот интерфейс. У него есть всего один метод: GetEnumerator(), который возвращает... собственно, итератор.

Интерфейс IEnumerator — «сам процесс перебора»

Это уже конкретный «библиотекарь», который ходит по полкам. У него есть три важных члена:

• Current — текущий элемент, на котором мы остановились (книга, которую библиотекарь держит в руках).
• MoveNext() — перейти к следующему элементу. Возвращает true, если переход удался, и false, если элементы закончились.
• Reset() — вернуться в начало (редко используется, но бывает нужно).

Когда ты пишешь foreach (var item in collection), компилятор C# невидимо для тебя делает вот что:

// То, что на самом деле происходит внутри цикла foreach
IEnumerator enumerator = collection.GetEnumerator();
try
{
    while (enumerator.MoveNext())  // Пока есть следующий элемент
    {
        var item = enumerator.Current;  // Берём текущий
        // ... твой код с item ...
    }
}
finally
{
    // Важно! Всегда освобождаем ресурсы
    if (enumerator is IDisposable disposable)
        disposable.Dispose();
}

Генераторы (yield return) — «ленивая фабрика»

А теперь самое интересное. В C# есть специальное ключевое слово yield return. Когда ты используешь его в методе, компилятор сам создаёт за тебя целый класс-итератор! Ты просто пишешь, что и когда возвращать, а всю «технику» (состояние, переходы, Current/MoveNext) компилятор генерирует автоматически.

Это похоже на то, как если бы ты сказал библиотекарю: «Иди по полкам, и каждый раз, когда видишь книгу в красной обложке, записывай её название». Ты не говоришь ему, как именно ходить и как записывать — он сам знает. Ты только описываешь правило отбора.

🔬 Как это работает под капотом: Компилятор превращает метод с yield return в конечный автомат (state machine). У этого автомата есть состояния: «до первого yield», «между yield-ами», «после последнего yield». Каждый раз, когда вызывается MoveNext(), автомат переходит в следующее состояние и возвращает нужное значение. Это очень эффективно!

Синтаксис в C# (.NET): все формы и варианты

Давай рассмотрим все способы создания итераторов и генераторов в C#. Их несколько, и каждый подходит для своей ситуации.

1. Ручная реализация IEnumerator

Самый низкоуровневый способ. Ты сам пишешь класс, который реализует интерфейс IEnumerator. Используется редко, но полезен для понимания.

2. Реализация IEnumerable через yield return

Самый популярный способ. Ты пишешь метод, который возвращает IEnumerable<T> и использует yield return.

3. Использование готовых итераторов LINQ

LINQ (Language Integrated Query) предоставляет множество методов, которые возвращают итераторы: Where, Select, Take, Skip и другие. Они все работают «лениво» — данные обрабатываются только когда ты начинаешь их перебирать.

4. Асинхронные итераторы (C# 8.0+)

Если твой код работает с сетью или файлами, можно использовать await foreach и yield return await. Это позволяет перебирать данные, которые приходят асинхронно (например, с сервера).

Способ	Когда использовать	Пример сигнатуры
Ручной IEnumerator	Когда нужен полный контроль над состоянием	class MyEnumerator : IEnumerator<int>
yield return	В 90% случаев — просто и понятно	IEnumerable<int> GetNumbers()
LINQ	Когда нужно отфильтровать или преобразовать данные	collection.Where(x => x > 5)
Асинхронный	Работа с сетью, файлами, стримами	IAsyncEnumerable<T>

Примеры кода — от простого к сложному

Пример 1: Простейший генератор чисел

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Вызываем метод-генератор. Обрати внимание: код метода ещё НЕ выполняется!
        IEnumerable<int> numbers = GetSimpleNumbers();
        
        Console.WriteLine("Начинаем перебор...");
        
        // Только здесь, в цикле foreach, метод начнёт работать
        foreach (int num in numbers)
        {
            Console.WriteLine($"Получили число: {num}");
        }
    }

    // Это метод-генератор. Ключевое слово yield return делает его особенным
    static IEnumerable<int> GetSimpleNumbers()
    {
        Console.WriteLine("  Запуск генератора...");
        
        yield return 1;  // Возвращаем 1 и "засыпаем" до следующего вызова
        Console.WriteLine("  Продолжаем после первого yield");
        
        yield return 2;  // Возвращаем 2 и снова "засыпаем"
        Console.WriteLine("  Продолжаем после второго yield");
        
        yield return 3;  // Возвращаем 3
        Console.WriteLine("  Генератор закончил работу");
    }
}

// Вывод программы:
// Начинаем перебор...
// Получили число: 1
//   Запуск генератора...
// Получили число: 2
//   Продолжаем после первого yield
// Получили число: 3
//   Продолжаем после второго yield
//   Генератор закончил работу

Объяснение: Обрати внимание на порядок вывода! Сначала печатается «Получили число: 1», а потом «Запуск генератора...». Это потому что генератор работает «лениво»: он делает ровно столько, сколько нужно для получения следующего элемента. Как только он доходит до yield return, он возвращает значение и запоминает своё положение. При следующем вызове он продолжает с того же места.

Пример 2: Генератор с условием (только чётные числа)

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Console.WriteLine("Чётные числа от 0 до 10:");
        foreach (int even in GetEvenNumbers(0, 10))
        {
            Console.Write($"{even} ");
        }
        // Вывод: 0 2 4 6 8 10
    }

    static IEnumerable<int> GetEvenNumbers(int start, int end)
    {
        // Перебираем все числа в диапазоне
        for (int i = start; i <= end; i++)
        {
            // Если число чётное — возвращаем его
            if (i % 2 == 0)
            {
                yield return i;  // Отдаём только чётные числа
            }
            // Нечётные числа просто пропускаем
        }
    }
}

Объяснение: Здесь генератор работает как «фильтр». Он перебирает все числа, но возвращает только те, которые подходят под условие. Это очень похоже на то, как работает LINQ-метод Where().

Пример 3: Бесконечный генератор (числа Фибоначчи)

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Console.WriteLine("Первые 10 чисел Фибоначчи:");
        
        int count = 0;
        foreach (long fib in GetFibonacciNumbers())
        {
            Console.Write($"{fib} ");
            count++;
            
            // Важно! Без этого условия цикл будет бесконечным
            if (count >= 10)
                break;
        }
        // Вывод: 0 1 1 2 3 5 8 13 21 34
    }

    // Бесконечный генератор чисел Фибоначчи
    static IEnumerable<long> GetFibonacciNumbers()
    {
        long a = 0;  // Первое число
        long b = 1;  // Второе число
        
        // Бесконечный цикл! Но это не страшно, потому что генератор
        // работает "лениво" — он выдаёт числа по одному
        while (true)
        {
            yield return a;  // Возвращаем текущее число
            
            // Вычисляем следующую пару
            long temp = a;
            a = b;
            b = temp + b;
        }
    }
}

Объяснение: Этот пример показывает главную силу генераторов — они могут быть бесконечными! Обычный список не может хранить бесконечное количество элементов, а генератор — может, потому что он не хранит их все, а создаёт на лету. Главное — не забыть поставить условие выхода из цикла foreach, иначе программа будет работать вечно.

Пример 4: Генератор с break (досрочное завершение)

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        Console.WriteLine("Поиск первого числа больше 1000 в ряду Фибоначчи:");
        
        foreach (long fib in GetFibonacciNumbers())
        {
            if (fib > 1000)
            {
                Console.WriteLine($"Нашли! Это {fib}");
                break;  // Досрочно завершаем перебор
            }
        }
    }

    static IEnumerable<long> GetFibonacciNumbers()
    {
        long a = 0, b = 1;
        while (true)
        {
            yield return a;
            long temp = a;
            a = b;
            b = temp + b;
        }
    }
}

Объяснение: Когда мы вызываем break в цикле foreach, генератор понимает, что больше не нужно выдавать значения. Компилятор генерирует код, который вызывает Dispose() у итератора, и генератор завершает свою работу. Это важно для освобождения ресурсов (например, открытых файлов).

Пример 5: Чтение файла построчно (реальная задача)

using System;
using System.Collections.Generic;
using System.IO;

class Program
{
    static void Main()
    {
        string filePath = "log.txt";  // Предположим, файл существует
        
        Console.WriteLine("Чтение файла построчно (только ошибки):");
        
        // Используем наш генератор для чтения файла
        foreach (string line in ReadFileLines(filePath))
        {
            // Обрабатываем только строки, содержащие "ERROR"
            if (line.Contains("ERROR"))
            {
                Console.WriteLine($"[ОШИБКА] {line}");
            }
        }
        
        Console.WriteLine("Файл прочитан. Память не перегружена!");
    }

    // Генератор для чтения файла построчно
    static IEnumerable<string> ReadFileLines(string filePath)
    {
        // using гарантирует, что файл будет закрыт даже при ошибке
        using (StreamReader reader = new StreamReader(filePath))
        {
            string line;
            // Читаем строку за строкой
            while ((line = reader.ReadLine()) != null)
            {
                // Возвращаем каждую строку по одной
                yield return line;
            }
        }
        // Файл автоматически закроется здесь (или раньше, если прервали foreach)
    }
}

Объяснение: Это классический пример использования генераторов для работы с большими данными. Файл размером 10 ГБ будет прочитан без загрузки в память — в каждый момент времени там находится только одна строка. Конструкция using гарантирует, что файл закроется, даже если мы прервём цикл досрочно.

Пример 6: Комбинация нескольких генераторов

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        // Комбинируем несколько генераторов
        var result = GetNumbers()
            .Where(x => x % 2 == 0)      // Оставляем только чётные
            .Select(x => x * 10)          // Умножаем на 10
            .Take(5);                     // Берём только первые 5
        
        Console.WriteLine("Результат комбинации:");
        foreach (var item in result)
        {
            Console.WriteLine(item);
        }
        // Вывод: 20, 40, 60, 80, 100
    }

    static IEnumerable<int> GetNumbers()
    {
        for (int i = 1; i <= 10; i++)
        {
            yield return i;
        }
    }
}

Объяснение: Генераторы отлично комбинируются друг с другом и с LINQ. Каждый метод (Where, Select, Take) тоже является генератором! Они создают цепочку, которая выполняется «лениво»: ни один элемент не будет обработан, пока мы не запустим foreach. Это называется «отложенное выполнение» (deferred execution).

Пример 7: Асинхронный генератор (C# 8.0+)

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Асинхронное чтение данных с сервера:");
        
        // await foreach — асинхронная версия foreach
        await foreach (string data in GetDataFromServerAsync())
        {
            Console.WriteLine($"Получен фрагмент: {data}");
        }
    }

    // Асинхронный генератор. Возвращает IAsyncEnumerable вместо IEnumerable
    static async IAsyncEnumerable<string> GetDataFromServerAsync()
    {
        using HttpClient client = new HttpClient();
        
        // Эмулируем получение данных частями
        for (int i = 0; i < 5; i++)
        {
            // Асинхронно ждём данные (не блокируем поток)
            await Task.Delay(500);  // Имитация задержки сети
            
            // Возвращаем очередную порцию данных
            yield return $"Пакет данных #{i + 1}";
        }
    }
}

Объяснение: Асинхронные генераторы — это современный способ работы с данными, которые приходят не сразу (из сети, с диска). Они не блокируют поток выполнения, пока ждут данные. Это особенно важно в GUI-приложениях (WPF, WinForms) и веб-приложениях (ASP.NET), где блокировка потока делает интерфейс «замершим».

Сравнение с Python: чем похоже и чем отличается

Если ты знаком с Python, ты заметишь много общего. Концепция итераторов и генераторов пришла в C# из функциональных языков, и Python тоже на неё повлиял. Но есть важные отличия.

Характеристика	C#	Python
Ключевое слово	yield return	yield
Тип возврата	IEnumerable<T> или IAsyncEnumerable<T>	Любой итерируемый объект (обычно генератор)
Строгая типизация	Да, тип элементов известен на этапе компиляции	Нет, типы проверяются во время выполнения
Асинхронность	Встроена с C# 8.0 (await foreach)	Через async for (Python 3.6+)
Генераторные выражения	Нет прямого аналога (используется LINQ)	(x for x in range(10))
Ленивость	Полная, все LINQ-методы ленивы	Полная, все генераторы ленивы
Производительность	Выше, нет накладных расходов на динамическую типизацию	Ниже из-за динамической природы языка

Главное отличие: В C# всё строго типизировано. Если ты объявил IEnumerable<int>, ты не сможешь случайно вернуть строку — компилятор не пропустит. В Python такой защиты нет, и ошибка проявится только во время выполнения. С одной стороны, Python гибче, с другой — в C# надёжнее.

Второе важное отличие: В C# нет «генераторных выражений» в стиле Python (x**2 for x in range(10)). Вместо этого используется LINQ: Enumerable.Range(0, 10).Select(x => x * x). Это чуть более многословно, но зато более читаемо для больших цепочек преобразований.

Типичные ошибки и подводные камни

Даже опытные разработчики иногда попадаются на этих граблях. Давай разберём самые частые ошибки.

Ошибка 1: Многократное выполнение генератора

// ПЛОХОЙ КОД:
var numbers = GetNumbers();  // Генератор ещё не выполнился
int count1 = numbers.Count();  // Выполняем генератор первый раз
int count2 = numbers.Count();  // Выполняем генератор ВТОРОЙ раз!

// ХОРОШИЙ КОД:
var numbers = GetNumbers().ToList();  // Принудительно выполняем и сохраняем в список
int count1 = numbers.Count;  // Просто читаем из списка
int count2 = numbers.Count;  // Быстро, без повторного выполнения

Почему это плохо: Каждый раз, когда ты вызываешь Count() или foreach, генератор выполняется заново! Если внутри генератора есть дорогие операции (чтение файла, запрос к БД), это приведёт к повторному выполнению. Всегда материализуй результат, если планируешь использовать его несколько раз.

Ошибка 2: Побочные эффекты в генераторе

// ПЛОХОЙ КОД:
static IEnumerable<int> BadGenerator(List<int> list)
{
    foreach (var item in list)
    {
        list.Remove(item);  // Меняем коллекцию во время перебора!
        yield return item;
    }
}

// ХОРОШИЙ КОД:
static IEnumerable<int> GoodGenerator(List<int> list)
{
    // Работаем с копией списка
    foreach (var item in list.ToList())
    {
        list.Remove(item);  // Теперь это безопасно
        yield return item;
    }
}

Почему это плохо: Изменение коллекции во время её перебора приводит к исключению InvalidOperationException. Генераторы не исключение — они тоже перебирают коллекцию. Если нужно модифицировать коллекцию, сначала создай её копию.

Ошибка 3: Забытый using для ресурсов

// ПЛОХОЙ КОД:
static IEnumerable<string> ReadFileBad(string path)
{
    StreamReader reader = new StreamReader(path);  // Ресурс не освобождается!
    string line;
    while ((line = reader.ReadLine()) != null)
    {
        yield return line;
    }
    // reader никогда не закроется, если foreach прервут досрочно
}

// ХОРОШИЙ КОД:
static IEnumerable<string> ReadFileGood(string path)
{
    using StreamReader reader = new StreamReader(path);  // using гарантирует закрытие
    string line;
    while ((line = reader.ReadLine()) != null)
    {
        yield return line;
    }
}

Почему это плохо: Если ты прервёшь foreach через break, генератор остановится, но файл останется открытым! Конструкция using гарантирует, что Dispose() будет вызван даже при досрочном завершении.

Ошибка 4: Путаница между IEnumerable и IEnumerator

// ПЛОХОЙ КОД:
var enumerable = GetNumbers();  // Это IEnumerable
var enumerator1 = enumerable.GetEnumerator();  // Получаем первый итератор
var enumerator2 = enumerable.GetEnumerator();  // Получаем ВТОРОЙ итератор

// Каждый итератор независим! Они будут перебирать коллекцию с начала
enumerator1.MoveNext();  // Текущий элемент: 1
enumerator2.MoveNext();  // Текущий элемент: 1 (независимо от первого!)

Почему это важно: IEnumerable — это «чертёж» коллекции, а IEnumerator — это «курсор» для перебора. Ты можешь создать много курсоров для одного чертежа, и каждый будет работать независимо. Это удобно, но может привести к путанице, если ты ожидаешь, что они будут синхронизированы.

Лучшие практики и советы профессионалов

Вот несколько правил, которые помогут тебе писать чистый и эффективный код с итераторами и генераторами.

Правило 1: Всегда материализуй результат при многократном использовании

Если ты собираешься перебирать коллекцию несколько раз или вызывать методы вроде Count(), First(), Any(), сначала преобразуй её в список или массив:

var result = GetExpensiveData().ToList();  // Выполняем один раз
if (result.Any())  // Быстрая проверка
{
    foreach (var item in result)  // Быстрый перебор
    {
        Process(item);
    }
}

Правило 2: Используй yield return для фильтрации, а не для создания новых коллекций

Генераторы идеальны для фильтрации существующих данных. Если тебе нужно просто создать новую коллекцию, используй LINQ:

// Хорошо: генератор для фильтрации
IEnumerable<int> GetAdults(IEnumerable<Person> people)
{
    foreach (var person in people)
    {
        if (person.Age >= 18)
            yield return person.Id;
    }
}

// Лучше: LINQ для простых преобразований
var adultIds = people.Where(p => p.Age >= 18).Select(p => p.Id);

Правило 3: Избегай глубокой вложенности yield return

Если твой метод-генератор становится слишком сложным, разбей его на несколько маленьких методов:

// ПЛОХО: один большой метод
IEnumerable<string> ProcessComplexData()
{
    // ... 50 строк кода с yield return ...
}

// ХОРОШО: разбито на маленькие методы
IEnumerable<string> ProcessComplexData()
{
    return FilterData()
        .TransformData()
        .FormatData();
}

Правило 4: Документируй «ленивое» поведение

Если твой метод возвращает IEnumerable и выполняет дорогие операции, обязательно укажи это в комментарии или XML-документации:

/// <summary>
/// Возвращает данные из базы данных. ВАЖНО: метод ленивый!
/// Данные будут загружены только при переборе результата.
/// </summary>
public IEnumerable<Order> GetOrders(DateTime from, DateTime to)
{
    // ...
}

Правило 5: Используй асинхронные генераторы для I/O операций

Если твой генератор читает файлы, делает HTTP-запросы или работает с базой данных, используй IAsyncEnumerable и await foreach. Это не даст твоему приложению «зависнуть»:

public async IAsyncEnumerable<string> ReadLinesAsync(string path)
{
    using var reader = new StreamReader(path);
    string? line;
    while ((line = await reader.ReadLineAsync()) != null)
    {
        yield return line;
    }
}

Вопросы для самопроверки

1. Вопрос: В чём разница между IEnumerable и IEnumerator?

   Ответ: IEnumerable — это интерфейс, который говорит «я могу быть перебран». У него есть метод GetEnumerator(), возвращающий IEnumerator. IEnumerator — это «курсор», который движется по коллекции. Он хранит текущее положение и умеет переходить к следующему элементу.

2. Вопрос: Что произойдёт, если вызвать MoveNext() после того, как коллекция закончилась?

   Ответ: Метод вернёт false. Повторные вызовы также будут возвращать false. Свойство Current в этом случае может выбросить исключение InvalidOperationException.

3. Вопрос: Можно ли использовать yield return в методе, который возвращает List<T>?

   Ответ: Нет. yield return работает только с методами, возвращающими IEnumerable, IEnumerator или их асинхронные версии. Для List<T> нужно сначала собрать все элементы в