C#是否支持多yield机制？如何简化枚举器方法调用

C#原生语法不支持直接在yield return中返回整个IEnumerable<T>集合（也就是你说的"多yield"批量返回），直接写yield return Inner()会编译报错——因为yield return要求返回的元素类型必须和方法的IEnumerable<T>泛型参数一致，而非另一个枚举器。

不过可以通过以下几种方式实现类似效果，避免重复编写foreach循环：

1. 使用LINQ的Concat合并序列 #

如果不需要保留yield的延迟执行特性（或本身就是延迟执行场景），直接用Concat拼接多个序列是最简洁的写法：

private IEnumerable<int> Outer()
{
    return new[] { 0 }
           .Concat(Inner())
           .Concat(new[] { 5 });
}

private IEnumerable<int> Inner()
{
    yield return 1;
    yield return 2;
    yield return 3;
    yield return 4;
}

这种方式完全不需要yield关键字，直接返回拼接后的序列，执行效果和需求一致，返回元素顺序为0、1、2、3、4、5。

2. 封装批量yield的辅助方法 #

如果需要保留yield的延迟执行（比如序列元素是动态生成、不想提前计算），可以封装辅助方法来隐藏重复的foreach逻辑：

基础封装版 #

public static class EnumerableExtensions
{
    // 封装批量yield的逻辑
    public static IEnumerable<T> YieldAll<T>(this IEnumerable<T> source)
    {
        foreach (var item in source)
        {
            yield return item;
        }
    }
}

// 使用扩展方法简化枚举器代码
private IEnumerable<int> Outer()
{
    yield return 0;
    foreach (var item in Inner().YieldAll())
    {
        yield return item;
    }
    yield return 5;
}

private IEnumerable<int> Inner()
{
    yield return 1;
    yield return 2;
    yield return 3;
    yield return 4;
}

进阶链式调用版 #

如果想让枚举器代码完全摆脱foreach，可以写一组链式调用的辅助方法：

private IEnumerable<int> Outer()
{
    return YieldItem(0)
           .ThenYieldAll(Inner())
           .ThenYieldItem(5);
}

// 返回单个元素的序列
private IEnumerable<T> YieldItem<T>(T item)
{
    yield return item;
}

// 在现有序列后追加另一个序列
private IEnumerable<T> ThenYieldAll<T>(this IEnumerable<T> source, IEnumerable<T> next)
{
    foreach (var item in source)
        yield return item;
    foreach (var item in next)
        yield return item;
}

// 在现有序列后追加单个元素
private IEnumerable<T> ThenYieldItem<T>(this IEnumerable<T> source, T item)
{
    foreach (var i in source)
        yield return i;
    yield return item;
}

private IEnumerable<int> Inner()
{
    yield return 1;
    yield return 2;
    yield return 3;
    yield return 4;
}

3. 核心说明 #

所有方案本质上还是基于foreach逐个yield元素，只是通过封装或LINQ隐藏了底层循环逻辑——C#至今没有提供直接批量返回整个序列的语法糖。如果不需要延迟执行，LINQ拼接是最优选择；如果需要延迟执行，封装辅助方法能让代码更易读。

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