C# IEnumerableマスターガイド：パフォーマンスを最大化する7つの実践テクニック

C#開発において、大規模データの効率的な処理は常に課題となります。IEnumerableは、この課題に対する強力な解決策を提供します。特に遅延評価の特性を活かすことで、メモリ効率の高いデータ処理を実現できます。
本記事では、IEnumerableの基本から実践的な最適化テクニックまでを、具体的なコード例と共に解説します。

IEnumerableとは？基礎から理解する遅延評価の仕組み

イテレーターパターンとIEnumerableの関係性を図解で解説

IEnumerableは、C#におけるコレクション操作の基盤となるインターフェースです。シーケンシャルなデータアクセスを可能にする重要な仕組みで、特に大規模データ処理において効率的なメモリ利用を実現します。

イテレーターパターンは、コレクションの要素を順番にアクセスする方法を標準化したデザインパターンです。C#では、このパターンをIEnumerable<T>とIEnumerator<T>という2つのインターフェースで実装しています。

// IEnumerableインターフェースの基本構造
public interface IEnumerable<T>
{
    IEnumerator<T> GetEnumerator();
}

// IEnumeratorインターフェースの基本構造
public interface IEnumerator<T>
{
    bool MoveNext();     // 次の要素に移動
    T Current { get; }   // 現在の要素を取得
    void Reset();        // 列挙をリセット
}

遅延評価がもたらすメモリ効率の向上とその仕組み

遅延評価（Lazy Evaluation）は、IEnumerableの最も重要な特徴の1つです。以下のコード例で、その動作を確認してみましょう。

// 遅延評価を示す実装例
public static IEnumerable<int> GenerateNumbers(int max)
{
    Console.WriteLine("ジェネレーター開始");
    for (int i = 0; i < max; i++)
    {
        Console.WriteLine($"数値 {i} を生成中");
        yield return i;
    }
}

// 使用例
var numbers = GenerateNumbers(1000000); // この時点では実際の計算は行われない
Console.WriteLine("生成開始");
foreach (var num in numbers.Take(5)) // 必要な要素だけが生成される
{
    Console.WriteLine($"取得した数値: {num}");
}

この実装により、以下のメリットが得られます。

遅延評価がメモリ使用量に与える影響を、具体的な例で見てみましょう。

// メモリ効率の比較
public static void CompareMemoryUsage()
{
    // 即時評価（ToList使用）
    var immediate = Enumerable.Range(0, 10000000).ToList(); // すぐにメモリを消費

    // 遅延評価（IEnumerable使用）
    var lazy = Enumerable.Range(0, 10000000); // この時点ではメモリをほとんど使用しない

    // 必要な部分だけを処理
    var first10 = lazy.Take(10); // 10個の要素だけを処理
}

IEnumerableと遅延評価の組み合わせは、以下の点で強力なツールとなります。

IEnumerableの実践的な活用シーン

大規模データ処理での効率的なメモリ管理手法

大規模データ処理において、IEnumerableの適切な活用は非常に重要です。以下に、実践的な実装パターンとベストプラクティスを紹介します。

実践的な実装パターン

public class LargeDataProcessor
{
    // 大規模データの効率的な処理例
    public static IEnumerable<ProcessedData> ProcessLargeDataSet(IEnumerable<RawData> rawData)
    {
        // チャンク単位での処理により、メモリ使用を最適化
        return rawData
            .Where(data => data != null)           // null チェック
            .Select(data => new ProcessedData      // データ変換
            {
                Id = data.Id,
                ProcessedValue = ProcessValue(data.Value)
            })
            .Where(processed => processed.IsValid); // バリデーション
    }

    // バッチ処理の実装例
    public static async Task ProcessInBatches<T>(
        IEnumerable<T> items, 
        int batchSize,
        Func<IEnumerable<T>, Task> batchProcessor)
    {
        var currentBatch = new List<T>(batchSize);

        foreach (var item in items)
        {
            currentBatch.Add(item);

            if (currentBatch.Count >= batchSize)
            {
                await batchProcessor(currentBatch);
                currentBatch.Clear();
            }
        }

        if (currentBatch.Any())
        {
            await batchProcessor(currentBatch);
        }
    }
}

効率的なデータ処理のためのパターン

// 大きなデータセットをチャンクに分割して処理
public static IEnumerable<IEnumerable<T>> Chunk<T>(
    this IEnumerable<T> source, 
    int chunkSize)
{
    while (source.Any())
    {
        yield return source.Take(chunkSize);
        source = source.Skip(chunkSize);
    }
}

ストリーミング処理におけるIEnumerableの威力

ストリーミング処理では、IEnumerableの遅延評価特性を最大限に活用できます。

public class StreamingDataProcessor
{
    // ストリーミングデータ処理の例
    public static IEnumerable<TResult> ProcessDataStream<TSource, TResult>(
        IEnumerable<TSource> source,
        Func<TSource, TResult> processor)
    {
        foreach (var item in source)
        {
            // 1項目ずつ処理して結果を返す
            yield return processor(item);
        }
    }

    // リアルタイムデータ処理の例
    public static async Task ProcessRealTimeData<T>(
        IEnumerable<T> dataStream,
        Func<T, Task> processor,
        CancellationToken cancellationToken = default)
    {
        foreach (var data in dataStream)
        {
            if (cancellationToken.IsCancellationRequested)
                break;

            await processor(data);
        }
    }
}

メモリ使用量の制御と最適化

// メモリ使用量を監視しながらの処理
public static IEnumerable<T> WithMemoryCheck<T>(
    this IEnumerable<T> source,
    long memoryThreshold)
{
    foreach (var item in source)
    {
        if (GC.GetTotalMemory(false) > memoryThreshold)
        {
            GC.Collect();
        }
        yield return item;
    }
}

// リソース解放の適切な管理
public static IEnumerable<T> WithDisposableTracking<T>(
    this IEnumerable<T> source,
    Action<T> disposeAction) where T : IDisposable
{
    foreach (var item in source)
    {
        yield return item;
        disposeAction(item);
    }
}

パフォーマンスを最大化する実装テクニック

不要なイテレーションを防ぐToListの適切な使用タイミング

ToListメソッドの不適切な使用は、パフォーマンスに大きな影響を与える可能性があります。以下に、適切な使用方法を示します。

public class ToListOptimization
{
    // 悪い例：不必要なToListの使用
    public static IEnumerable<int> BadExample(IEnumerable<int> numbers)
    {
        var list = numbers.ToList(); // 不要なメモリ割り当て
        return list.Where(n => n > 0);
    }

    // 良い例：必要な場合のみToListを使用
    public static IEnumerable<int> GoodExample(IEnumerable<int> numbers)
    {
        // 複数回の列挙が必要な場合のみToListを使用
        if (RequiresMultipleEnumeration(numbers))
        {
            return numbers.ToList();
        }
        return numbers;
    }

    // ToListが必要なケース
    public static void ValidToListUsage(IEnumerable<int> numbers)
    {
        // 1. 複数回の列挙が必要な場合
        var count = numbers.Count();
        var sum = numbers.Sum();

        // 2. スレッドセーフな操作が必要な場合
        var list = numbers.ToList();
        Parallel.ForEach(list, ProcessItem);
    }
}

メモリリークを防ぐためのusingステートメントの活用

IEnumerableを使用する際、適切なリソース管理が重要です。

public class ResourceManagement
{
    // メモリリークを防ぐ実装例
    public static async Task ProcessLargeFile(string filePath)
    {
        // using ステートメントによる適切なリソース解放
        await using var fileStream = File.OpenRead(filePath);
        using var reader = new StreamReader(fileStream);

        // イテレーターメソッドの実装
        static IEnumerable<string> ReadLines(StreamReader reader)
        {
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                yield return line;
            }
        }

        foreach (var line in ReadLines(reader))
        {
            await ProcessLine(line);
        }
    }

    // IDisposableを実装したカスタムイテレーター
    public class DisposableEnumerator<T> : IEnumerable<T>, IDisposable
    {
        private readonly IEnumerable<T> _source;
        private bool _disposed;

        public DisposableEnumerator(IEnumerable<T> source)
        {
            _source = source;
        }

        public IEnumerator<T> GetEnumerator()
        {
            if (_disposed)
                throw new ObjectDisposedException(nameof(DisposableEnumerator<T>));

            return _source.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

        public void Dispose()
        {
            if (!_disposed)
            {
                // リソースの解放処理
                _disposed = true;
            }
        }
    }
}

複数回の列挙を避けるキャッシュ戦略

効率的なキャッシュ戦略の実装例を示します。

public class CachingStrategies
{
    // メモ化を使用したキャッシュ実装
    public static class Memoization<TKey, TValue>
    {
        private static readonly ConcurrentDictionary<TKey, TValue> _cache 
            = new ConcurrentDictionary<TKey, TValue>();

        public static IEnumerable<TValue> GetOrCreate(
            TKey key, 
            Func<TKey, IEnumerable<TValue>> valueFactory)
        {
            if (_cache.TryGetValue(key, out var cachedValue))
            {
                return new[] { cachedValue };
            }

            var values = valueFactory(key).ToList();
            foreach (var value in values)
            {
                _cache.TryAdd(key, value);
                yield return value;
            }
        }
    }

    // 遅延キャッシュの実装
    public static IEnumerable<T> LazyCache<T>(
        this IEnumerable<T> source,
        int cacheSize = 1000)
    {
        var cache = new Queue<T>(cacheSize);

        foreach (var item in source)
        {
            if (cache.Count >= cacheSize)
            {
                cache.Dequeue();
            }

            cache.Enqueue(item);
            yield return item;
        }
    }
}

これらのテクニックを適切に組み合わせることで、IEnumerableを使用したアプリケーションのパフォーマンスを最大限に引き出すことができます。

LINQとIEnumerableの相乗効果を実現する

チェーンメソッドの最適化テクニック

LINQのチェーンメソッドは強力ですが、適切に使用しないとパフォーマンスに影響を与える可能性があります。以下に、最適化のテクニックを示します。

public class LinqOptimization
{
    // 非効率的なチェーンメソッドの例
    public static IEnumerable<int> IneffectiveChaining(IEnumerable<int> numbers)
    {
        return numbers
            .Where(n => n > 0)
            .ToList()           // 不要なリスト化
            .Where(n => n < 100)
            .ToList()           // 再度の不要なリスト化
            .OrderBy(n => n);
    }

    // 最適化されたチェーンメソッドの例
    public static IEnumerable<int> OptimizedChaining(IEnumerable<int> numbers)
    {
        return numbers
            .Where(n => n > 0 && n < 100)  // 条件をマージ
            .OrderBy(n => n);              // 最後に一度だけ実行
    }

    // 複雑な処理のパフォーマンス最適化例
    public static IEnumerable<Customer> OptimizeComplexQuery(
        IEnumerable<Customer> customers,
        IEnumerable<Order> orders)
    {
        // 頻繁に使用するデータをキャッシュ
        var activeOrders = orders
            .Where(o => o.IsActive)
            .ToLookup(o => o.CustomerId);

        return customers
            .Where(c => c.IsActive)
            .Select(c => new Customer
            {
                Id = c.Id,
                Name = c.Name,
                Orders = activeOrders[c.Id]  // ルックアップを使用して効率的に結合
            });
    }
}

パフォーマンスを意識したLINQオペレーターの選択

LINQオペレーターの選択は、パフォーマンスに大きな影響を与えます。

public class LinqOperatorOptimization
{
    // 効率的なオペレーター選択の例
    public static class QueryOptimization
    {
        // First vs FirstOrDefault の適切な使い分け
        public static T GetItem<T>(IEnumerable<T> items, Func<T, bool> predicate)
        {
            // 要素が必ず存在する場合はFirstを使用
            if (ItemExists(items))
            {
                return items.First(predicate);
            }

            // 要素が存在しない可能性がある場合はFirstOrDefaultを使用
            return items.FirstOrDefault(predicate);
        }

        // Any vs Count の使い分け
        public static bool HasElements<T>(IEnumerable<T> items, Func<T, bool> predicate)
        {
            // 存在確認のみの場合はAnyを使用（より効率的）
            return items.Any(predicate);

            // 以下は非効率
            // return items.Count(predicate) > 0;
        }

        // Select + Where vs Where + Select の最適化
        public static IEnumerable<TResult> OptimizeSelectWhere<TSource, TResult>(
            IEnumerable<TSource> source,
            Func<TSource, TResult> selector,
            Func<TResult, bool> predicate)
        {
            // 処理の順序を最適化
            return source
                .Where(item => predicate(selector(item)))  // 先にフィルタリング
                .Select(selector);                         // 後に変換
        }
    }

    // パフォーマンスを考慮したグループ化処理
    public static class GroupingOptimization
    {
        public static IEnumerable<IGrouping<TKey, TSource>> OptimizeGrouping<TSource, TKey>(
            IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector)
        {
            // ToLookupを使用した効率的なグループ化
            return source.ToLookup(keySelector);
        }

        // 集計処理の最適化
        public static IDictionary<TKey, int> OptimizeAggregation<TSource, TKey>(
            IEnumerable<TSource> source,
            Func<TSource, TKey> keySelector)
        {
            return source
                .GroupBy(keySelector)
                .ToDictionary(
                    g => g.Key,
                    g => g.Count());
        }
    }
}

これらの最適化テクニックを適切に組み合わせることで、LINQとIEnumerableの相乗効果を最大限に引き出すことができます。

IEnumerableの落とし穴と対処法

メモリリークの主な原因と防止策

IEnumerableの使用時によく発生するメモリリークの原因と、その対処方法を解説します。

public class MemoryLeakPrevention
{
    // メモリリークが発生する例
    public class ProblematicImplementation
    {
        private IEnumerable<LargeObject> _cachedData;

        // 問題のある実装
        public void ProcessData(IEnumerable<LargeObject> data)
        {
            _cachedData = data;  // 参照を保持し続ける

            foreach (var item in _cachedData)
            {
                ProcessItem(item);
            }
        }
    }

    // 改善された実装
    public class ImprovedImplementation
    {
        private readonly List<LargeObject> _cachedData;

        // 必要な場合のみデータをキャッシュ
        public void ProcessData(IEnumerable<LargeObject> data)
        {
            // 明示的にリストに変換してスコープを制限
            using var enumerator = data.GetEnumerator();
            while (enumerator.MoveNext())
            {
                ProcessItem(enumerator.Current);
            }
        }

        // 大きなデータセットの処理
        public async Task ProcessLargeDataSet(IEnumerable<LargeObject> data)
        {
            const int batchSize = 1000;
            var batch = new List<LargeObject>(batchSize);

            foreach (var item in data)
            {
                batch.Add(item);

                if (batch.Count >= batchSize)
                {
                    await ProcessBatch(batch);
                    batch.Clear();
                }
            }

            if (batch.Any())
            {
                await ProcessBatch(batch);
            }
        }
    }

    // リソース解放を確実に行う実装
    public class ResourceManagement : IDisposable
    {
        private bool _disposed;
        private readonly IEnumerator<LargeObject> _enumerator;

        public ResourceManagement(IEnumerable<LargeObject> data)
        {
            _enumerator = data.GetEnumerator();
        }

        public void ProcessNext()
        {
            if (_disposed)
                throw new ObjectDisposedException(nameof(ResourceManagement));

            if (_enumerator.MoveNext())
            {
                ProcessItem(_enumerator.Current);
            }
        }

        public void Dispose()
        {
            if (!_disposed)
            {
                _enumerator.Dispose();
                _disposed = true;
            }
        }
    }
}

無限ループを防ぐための実装パターン

無限ループを防ぐための安全な実装パターンを示します。

public class InfiniteLoopPrevention
{
    // 安全なイテレーター実装
    public static class SafeEnumeration
    {
        // タイムアウト付きイテレーター
        public static IEnumerable<T> WithTimeout<T>(
            this IEnumerable<T> source,
            TimeSpan timeout)
        {
            var startTime = DateTime.UtcNow;

            foreach (var item in source)
            {
                if (DateTime.UtcNow - startTime > timeout)
                {
                    throw new TimeoutException("Enumeration exceeded timeout");
                }

                yield return item;
            }
        }

        // 最大イテレーション回数を制限
        public static IEnumerable<T> WithMaxIterations<T>(
            this IEnumerable<T> source,
            int maxIterations)
        {
            var count = 0;

            foreach (var item in source)
            {
                if (count >= maxIterations)
                {
                    throw new InvalidOperationException(
                        "Maximum iteration count exceeded");
                }

                yield return item;
                count++;
            }
        }

        // 無限ループ検出
        public static IEnumerable<T> WithCycleDetection<T>(
            this IEnumerable<T> source,
            IEqualityComparer<T> comparer = null)
        {
            comparer ??= EqualityComparer<T>.Default;
            var seen = new HashSet<T>(comparer);

            foreach (var item in source)
            {
                if (!seen.Add(item))
                {
                    throw new InvalidOperationException("Cycle detected");
                }

                yield return item;
            }
        }
    }
}

これらの対策を適切に実装することで、IEnumerableを安全かつ効率的に使用することができます。

ユニットテストでのIEnumerableの取り扱い

モックを使用した効果的なテスト手法

IEnumerableを使用するコードのテストでは、適切なモックの作成が重要です。

// テスト対象のサービス
public interface IDataService
{
    IEnumerable<Customer> GetCustomers();
}

public class CustomerProcessor
{
    private readonly IDataService _dataService;

    public CustomerProcessor(IDataService dataService)
    {
        _dataService = dataService;
    }

    public IEnumerable<Customer> GetActiveCustomers()
    {
        return _dataService.GetCustomers()
            .Where(c => c.IsActive);
    }
}

// テストコード
[TestFixture]
public class CustomerProcessorTests
{
    private Mock<IDataService> _mockDataService;
    private CustomerProcessor _processor;

    [SetUp]
    public void Setup()
    {
        _mockDataService = new Mock<IDataService>();
        _processor = new CustomerProcessor(_mockDataService.Object);
    }

    [Test]
    public void GetActiveCustomers_ReturnsOnlyActiveCustomers()
    {
        // Arrange
        var testData = new List<Customer>
        {
            new Customer { Id = 1, IsActive = true },
            new Customer { Id = 2, IsActive = false },
            new Customer { Id = 3, IsActive = true }
        };

        _mockDataService
            .Setup(s => s.GetCustomers())
            .Returns(testData);

        // Act
        var result = _processor.GetActiveCustomers().ToList();

        // Assert
        Assert.That(result.Count, Is.EqualTo(2));
        Assert.That(result.All(c => c.IsActive), Is.True);
    }
}

一般的なテストケースとアサーションパターン

IEnumerableのテストで使用する一般的なパターンを示します。

[TestFixture]
public class IEnumerableTestPatterns
{
    [Test]
    public void TestSequenceEquality()
    {
        // Arrange
        var expected = new[] { 1, 2, 3 };
        var actual = GetNumbers();

        // Assert
        Assert.That(actual, Is.EqualTo(expected));
    }

    [Test]
    public void TestSequenceOrder()
    {
        // Arrange
        var numbers = new[] { 3, 1, 2 };
        var orderedNumbers = OrderNumbers(numbers);

        // Assert
        Assert.That(orderedNumbers, Is.Ordered);
    }

    [Test]
    public void TestCollectionProperties()
    {
        // Arrange
        var numbers = GetNumbers();

        // Assert
        Assert.Multiple(() =>
        {
            Assert.That(numbers, Is.Not.Empty);
            Assert.That(numbers, Has.Exactly(3).Items);
            Assert.That(numbers, Has.Member(1));
            Assert.That(numbers, Is.Unique);
        });
    }

    [Test]
    public void TestLazyEvaluation()
    {
        // Arrange
        var executionCount = 0;
        IEnumerable<int> numbers = Enumerable.Range(1, 10)
            .Select(n =>
            {
                executionCount++;
                return n;
            });

        // Act
        var first = numbers.First();

        // Assert
        Assert.That(executionCount, Is.EqualTo(1));
    }

    [Test]
    public void TestInfiniteSequence()
    {
        // Arrange
        var infiniteSequence = GenerateInfiniteSequence();

        // Act & Assert
        Assert.That(
            () => infiniteSequence.ToList(),
            Throws.TypeOf<OutOfMemoryException>());
    }
}

// テストヘルパークラス
public class IEnumerableTestHelper
{
    // パフォーマンステスト用のヘルパーメソッド
    public static void AssertPerformance<T>(
        IEnumerable<T> sequence,
        TimeSpan expectedMaxDuration)
    {
        var stopwatch = Stopwatch.StartNew();
        var result = sequence.ToList();
        stopwatch.Stop();

        Assert.That(
            stopwatch.Elapsed,
            Is.LessThan(expectedMaxDuration),
            $"Operation took {stopwatch.Elapsed} which exceeds expected {expectedMaxDuration}");
    }

    // シーケンス比較用のヘルパーメソッド
    public static void AssertSequencesEqual<T>(
        IEnumerable<T> expected,
        IEnumerable<T> actual,
        IEqualityComparer<T> comparer = null)
    {
        comparer ??= EqualityComparer<T>.Default;

        using var expectedEnumerator = expected.GetEnumerator();
        using var actualEnumerator = actual.GetEnumerator();

        var index = 0;
        while (true)
        {
            var hasExpected = expectedEnumerator.MoveNext();
            var hasActual = actualEnumerator.MoveNext();

            if (!hasExpected && !hasActual)
                return;

            Assert.That(
                hasExpected,
                Is.EqualTo(hasActual),
                $"Sequences have different lengths at index {index}");

            Assert.That(
                comparer.Equals(actualEnumerator.Current, expectedEnumerator.Current),
                Is.True,
                $"Sequences differ at index {index}");

            index++;
        }
    }
}

これらのパターンを活用することで、IEnumerableを使用するコードの品質を効果的に確保できます。

次のステップ：より深いC#コレクション管理の世界へ

IQueryableとの使い分けで実現する最適化

IEnumerableとIQueryableの適切な使い分けは、アプリケーションのパフォーマンスに大きな影響を与えます。

public class QueryableOptimization
{
    private readonly DbContext _context;

    public QueryableOptimization(DbContext context)
    {
        _context = context;
    }

    // IQueryableを使用した効率的なデータベースクエリ
    public IQueryable<Customer> GetCustomersByFilter(
        string nameFilter = null,
        bool? isActive = null)
    {
        var query = _context.Customers.AsQueryable();

        if (!string.IsNullOrEmpty(nameFilter))
        {
            query = query.Where(c => c.Name.Contains(nameFilter));
        }

        if (isActive.HasValue)
        {
            query = query.Where(c => c.IsActive == isActive.Value);
        }

        return query; // クエリはまだ実行されていない
    }

    // IEnumerableとIQueryableの使い分け
    public class QueryComparison
    {
        // メモリ内処理に適したIEnumerable
        public static IEnumerable<T> ProcessInMemory<T>(
            IEnumerable<T> items,
            Func<T, bool> complexFilter)
        {
            return items
                .Where(complexFilter)
                .Select(item => ProcessItem(item));
        }

        // データベースクエリに適したIQueryable
        public static IQueryable<T> ProcessInDatabase<T>(
            IQueryable<T> query,
            Expression<Func<T, bool>> simpleFilter)
        {
            return query
                .Where(simpleFilter)
                .Select(item => item);
        }
    }
}

非同期ストリーム処理への発展的な応用

C# 8.0で導入された非同期ストリームを使用した高度な実装例。

public class AsyncStreamProcessing
{
    // 非同期ストリームの基本実装
    public static async IAsyncEnumerable<T> ProcessItemsAsync<T>(
        IEnumerable<T> items)
    {
        foreach (var item in items)
        {
            await Task.Delay(100); // 非同期処理のシミュレーション
            yield return item;
        }
    }

    // 実践的な非同期ストリーム処理
    public class AsyncDataProcessor
    {
        // バッチ処理と非同期ストリームの組み合わせ
        public static async IAsyncEnumerable<ProcessedData> 
            ProcessLargeDataSetAsync(
                IEnumerable<RawData> rawData,
                int batchSize = 1000)
        {
            var batch = new List<RawData>(batchSize);

            foreach (var item in rawData)
            {
                batch.Add(item);

                if (batch.Count >= batchSize)
                {
                    await foreach (var processed in ProcessBatchAsync(batch))
                    {
                        yield return processed;
                    }
                    batch.Clear();
                }
            }

            if (batch.Any())
            {
                await foreach (var processed in ProcessBatchAsync(batch))
                {
                    yield return processed;
                }
            }
        }

        // パラレル処理と非同期ストリームの組み合わせ
        public static async IAsyncEnumerable<ProcessedData> 
            ProcessWithParallelismAsync(
                IEnumerable<RawData> rawData,
                int maxParallelism = 3)
        {
            var semaphore = new SemaphoreSlim(maxParallelism);
            var processingTasks = new List<Task<ProcessedData>>();

            foreach (var item in rawData)
            {
                await semaphore.WaitAsync();

                processingTasks.Add(Task.Run(async () =>
                {
                    try
                    {
                        return await ProcessItemAsync(item);
                    }
                    finally
                    {
                        semaphore.Release();
                    }
                }));

                // 完了したタスクの結果を順次yield
                while (processingTasks.Any())
                {
                    var completed = await Task.WhenAny(processingTasks);
                    processingTasks.Remove(completed);
                    yield return await completed;
                }
            }
        }
    }
}

これらの発展的な実装を理解し活用することで、より効率的で堅牢なアプリケーションを開発することができます。

IEnumerableのまとめ

IEnumerableは単なるデータ列挙のためのインターフェースではなく、効率的なデータ処理を実現するための重要な基盤です。
遅延評価を理解し、適切な実装パターンを選択することで、メモリ効率が高く、パフォーマンスの良いアプリケーションを開発することができます。また、適切なテスト手法を組み合わせることで、保守性の高い実装を実現できます。