含yield的方法中能否多次遍历同一IEnumerable？如何优化可读性？

问题背景与异常现象 #

我有一个整数列表(0,1,2,3,4,5,6,7,8,9,10)，需要过滤首尾元素提取中间的(5,6,7,8)。我编写了如下使用yield的方法，通过两次foreach遍历同一IEnumerable<int>并执行不同过滤逻辑：

IEnumerable<int> GetCapturedTimeLapsesWithRatios(IEnumerable<int> allTimeLapsesProfitabilitiesResult, int from, int to)
{
    foreach (var item in allTimeLapsesProfitabilitiesResult)
    {
        if (item <= from)
        {
            Console.WriteLine(item);
            continue;
        }
        else
        {
            if (item >= to)
            {
                Console.WriteLine("if (item >= to) " + item);
                yield return item;
                yield break;
            }
            else
            {
                Console.WriteLine("else " + item);
                yield return item;
                break;
            }
        }
    }

    foreach (var item in allTimeLapsesProfitabilitiesResult)
    {
        if (item < to)
        {
            Console.WriteLine("if (item < to) " + item);
            yield return item;
        }
        else
        {
            Console.WriteLine("else " + item);
            yield return item;
            yield break;
        }
    }
}

GetCapturedTimeLapsesWithRatios(new List<int>() {0,1,2,3,4,5,6,7,8,9,10 }, 4, 8);

但结果不符合预期：返回{ 5, 0, 1, 2, 3, 4, 5, 6, 7, 8 }，第二次foreach从头开始迭代，而非从第一次结束的位置继续。

临时解决方案与痛点 #

我改用GetEnumerator()手动控制迭代器，实现了预期逻辑，但代码可读性大幅下降：

IEnumerable<int> GetCapturedTimeLapsesWithRatios(IEnumerable<int> allTimeLapsesProfitabilitiesResult, int from, int to)
{
    using (var enumerator = allTimeLapsesProfitabilitiesResult.GetEnumerator())
    {
        do
        {
            if (!enumerator.MoveNext())
                yield break;

            var item = enumerator.Current;
            if (item <= from)
            {
                Console.WriteLine(item);
                continue;
            }
            else
            {
                if (item >= to)
                {
                    Console.WriteLine("if (item >= to) " + item);
                    yield return item;
                    yield break;
                }
                else
                {
                    Console.WriteLine("else " + item);
                    yield return item;
                    break;
                }
            }
        } while (true);

        do
        {
            if (!enumerator.MoveNext())
                yield break;

            var item = enumerator.Current;

            if (item < to)
            {
                Console.WriteLine("if (item < to) " + item);
                yield return item;
            }
            else
            {
                Console.WriteLine("else " + item);
                yield return item;
                yield break;
            }
        } while (true);
    }
}

GetCapturedTimeLapsesWithRatios(new List<int>() {0,1,2,3,4,5,6,7,8,9,10 }, 4, 8);

实际业务需求 #

我的真实场景是处理升序排列的DateOnly序列（每个元素代表区间终点，前一个元素为当前区间起点），需筛选出能包裹指定输入区间的对应DateOnly值。例如：

输入序列：

2024-10-01
2024-10-10
2024-10-15
2024-10-25
2024-10-28
2024-10-30

输入区间：2024-10-12 to 2024-10-27，需返回：

2024-10-15
2024-10-25
2024-10-28

由于输入序列是有序的，我希望避免重复判断已无需检查的条件（如找到大于from的元素后，后续无需再判断该条件），因此想分阶段用不同过滤逻辑遍历。

核心疑问解答 #

1. 在含yield的方法中，能否通过多次foreach对同一IEnumerable实现接续式遍历？ #

不能。每次foreach循环都会隐式调用IEnumerable<T>.GetEnumerator()生成一个全新的迭代器实例，每个迭代器都是独立从头开始遍历原集合的。因此第一次foreach结束后，第二次foreach会重新创建迭代器，从头开始遍历，无法接续之前的迭代位置。

2. 若使用手动迭代器，如何优化代码可读性？ #

可以通过以下几种方式优化：

• 拆分阶段逻辑为独立方法：将不同遍历阶段的逻辑提取成单独方法，接收IEnumerator<T>作为参数，主方法仅负责初始化迭代器和调用各阶段方法，让流程更清晰。
• 利用有序序列特性简化逻辑：因为输入是升序排列的，可直接定位到起始位置后一次性收集所需元素，无需分多次遍历。
• 简化嵌套条件与添加注释：拆分复杂的嵌套条件，添加注释说明每个阶段的意图，降低代码理解成本。

针对你的业务需求，优化后的代码示例如下：

IEnumerable<DateOnly> GetEnclosingDates(IEnumerable<DateOnly> sortedDates, DateOnly from, DateOnly to)
{
    using var enumerator = sortedDates.GetEnumerator();
    bool hasStarted = false;

    // 跳过所有小于等于from的元素，找到第一个符合要求的起始元素
    while (enumerator.MoveNext())
    {
        if (enumerator.Current > from)
        {
            yield return enumerator.Current;
            hasStarted = true;
            break;
        }
    }

    if (!hasStarted) yield break;

    // 收集后续元素，直到找到第一个大于等于to的元素（包含该元素）
    while (enumerator.MoveNext())
    {
        yield return enumerator.Current;
        if (enumerator.Current >= to)
        {
            break;
        }
    }
}

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