Какие существуют подходы и паттерны при работе с yield return (ленивыми последовательностями) в C#?

Слушай, вот эта штука yield return в C# — это ж просто песня, а не фича. По сути, она для итераторов и для этой вашей ленивой хуйни (lazy evaluation). Сейчас разжую, как её правильно хавать, чтобы не выстрелить себе в ногу.

1. Ленивая генерация, чтобы память не ебашить

Вместо того чтобы сразу создавать всю хуеву тучу данных, ты их выдаёшь по одному, прямо в процессе. Для бесконечных или просто дохуя больших списков — самое то.

public static IEnumerable<int> GenerateFibonacci(int count) {
    int a = 0, b = 1;
    for (int i = 0; i < count; i++) {
        yield return a;
        int temp = a;
        a = b;
        b = temp + b;
    }
}
// Использование: foreach (var num in GenerateFibonacci(10)) { ... }
// Каждое число высчитывается только когда до него доходит цикл, а не все сразу. Умно, блядь.

2. Конвейеры, или как вода в трубе

Можно делать такие цепочки методов, где данные текут как по трубе, элемент за элементом. Один метод фильтрует, другой преобразует — красота.

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

public static IEnumerable<int> Square(this IEnumerable<int> source) {
    foreach (var num in source) yield return num * num;
}

public static IEnumerable<string> Format(this IEnumerable<int> source) {
    foreach (var num in source) yield return $"Value: {num}";
}

// Собираем конвейер: достали число -> возвели в квадрат -> отформатировали
var result = GetNumbers().Square().Format();
// Каждый элемент проходит по всей этой цепочке, прежде чем мы возьмёмся за следующий. Лениво и эффективно.

3. Фильтрация, которая работает только когда надо

Ты можешь написать свой фильтр, и он сработает не в момент вызова метода, а в момент, когда ты реально начинаешь перебирать результаты. Это, блядь, важно.

public static IEnumerable<T> WhereLazy<T>(this IEnumerable<T> source, Predicate<T> predicate) {
    foreach (var item in source) {
        if (predicate(item)) {
            yield return item;
        }
    }
}
// Фильтрация начнётся только тут, когда полезем в цикл foreach.
var evenNumbers = GetNumbers().WhereLazy(n => n % 2 == 0);

4. Склеивание всего со всем

Нужно смержить кучу списков в один? yield return сделает это элегантно и без лишних телодвижений.

public static IEnumerable<T> Merge<T>(params IEnumerable<T>[] sequences) {
    foreach (var seq in sequences) {
        foreach (var item in seq) {
            yield return item;
        }
    }
}

5. Бесконечные потоки, ёпта

Хочешь генерировать числа до скончания времён? Запросто. Главное — не забыть этот поток как-то ограничить, а то зависнешь нахуй.

public static IEnumerable<int> RandomNumbers(Random rng) {
    while (true) {
        yield return rng.Next();
    }
}
// ОБЯЗАТЕЛЬНО используй с .Take(), иначе пиши пропало.
var tenRandomNumbers = RandomNumbers(new Random()).Take(10);

А теперь, блядь, важные подводные камни

• Каждый раз заново: Код итератора выполняется каждый раз, когда ты начинаешь перечисление заново. Если там тяжёлая логика — кешируй результат (.ToList() или .ToArray()), а то сожрёт все ресурсы.
• Не лезь со своим состоянием: Менять что-то глобальное во время работы итератора — верный путь к боли, особенно если перечислять его несколько раз. Побочные эффекты, ёпта.
• В try-catch его не засунешь: Да, вот такой прикол компилятора. yield return нельзя писать внутри блока try, если там есть catch. Запомни это как "Отче наш".

Короче говоря, yield return — это охуенный инструмент, когда нужно работать с потоками данных, не загружая всё в память сразу. Используй для конвейеров, фильтров и генераторов, но помни про повторное выполнение и не выёбывайся с изменением состояния.