如何在多个循环/订阅者间共享IEnumerable的yield return结果？

当然可以借助.NET原生的IEnumerable、foreach、委托等特性实现需求，核心是主动控制源集合的枚举过程，把每个元素一次性推送给所有计算逻辑，避免重复枚举。下面是几种实用方案：

方案1：直接手动遍历+多逻辑消费 #

这是最直观的实现，没有额外封装，直接遍历一次源集合，将每个元素传递给所有计算函数：

// 定义独立的计算逻辑
void UpdateSum(int value, ref int sum) => sum += value;
void UpdateMax(int value, ref int max) => max = Math.Max(max, value);
void UpdateMin(int value, ref int min) => min = Math.Min(min, value);

// 待计算的源集合
var numbers = Enumerable.Range(1, 10);

// 初始化计算结果变量
int sum = 0;
int max = int.MinValue;
int min = int.MaxValue;

// 单次循环，每个元素同步传给所有计算逻辑
foreach (var num in numbers)
{
    UpdateSum(num, ref sum);
    UpdateMax(num, ref max);
    UpdateMin(num, ref min);
}

Console.WriteLine($"Sum: {sum}, Max: {max}, Min: {min}");

这个方案完全依赖原生语法，没有任何额外依赖，确保源集合只被枚举一次。

方案2：封装成可复用的广播工具类 #

如果需要复用这个“单次枚举多消费”的逻辑，可以封装一个扩展方法，让代码更简洁：

public static class EnumerableExtensions
{
    public static void Broadcast<T>(this IEnumerable<T> source, params Action<T>[] handlers)
    {
        foreach (var item in source)
        {
            foreach (var handler in handlers)
            {
                handler(item);
            }
        }
    }
}

// 使用示例
var numbers = Enumerable.Range(1, 10);

int sum = 0;
int max = int.MinValue;
int min = int.MaxValue;

// 直接调用扩展方法传入所有计算逻辑
numbers.Broadcast(
    num => sum += num,
    num => max = Math.Max(max, num),
    num => min = Math.Min(min, num)
);

Console.WriteLine($"Sum: {sum}, Max: {max}, Min: {min}");

这个封装可以在多个场景复用，调用时只需要传入源集合和各个独立的计算委托即可。

方案3：基于yield return实现共享枚举（适合需保持IEnumerable接口的场景） #

如果你的计算逻辑需要以IEnumerable的形式存在（比如要使用LINQ方法），可以实现一个“热”枚举器，让多个消费者共享同一个源枚举过程（默认IEnumerable是冷枚举，每个消费者会重新遍历源）：

public static IEnumerable<T> CreateSharedEnumerable<T>(IEnumerable<T> source)
{
    var itemQueue = new Queue<T>();
    using var enumerator = source.GetEnumerator();
    bool hasMoreItems = true;

    while (hasMoreItems)
    {
        if (itemQueue.Count == 0)
        {
            hasMoreItems = enumerator.MoveNext();
            if (hasMoreItems)
            {
                itemQueue.Enqueue(enumerator.Current);
            }
        }

        if (itemQueue.Count > 0)
        {
            yield return itemQueue.Dequeue();
        }
    }
}

// 使用示例
var numbers = Enumerable.Range(1, 10);
var sharedNumbers = CreateSharedEnumerable(numbers);

// 多个LINQ操作共享同一个源枚举
var sum = sharedNumbers.Sum();
var max = sharedNumbers.Max();
var min = sharedNumbers.Min();

Console.WriteLine($"Sum: {sum}, Max: {max}, Min: {min}");

注意：这个方案如果是单线程依次调用多个LINQ方法，会保证源只被枚举一次；如果是多线程并发消费，需要添加锁保证线程安全。

关键提醒 #

默认的IEnumerable是冷枚举，每个消费者（比如调用Sum()、Max()）都会重新执行一遍源集合的遍历逻辑，这就是你之前遇到多次枚举的原因。上面的所有方案都是通过主动控制枚举流程，让所有计算逻辑共享同一次遍历的元素，从而避免重复枚举。

内容的提问来源于stack exchange，提问作者CodeArtist