在C#里，yield是一个看起来有点神秘的关键字。很多人第一次见到它都是在遍历集合的代码里，比如foreach (var item in GetItems())，点进方法内部却发现没有return语句，只有一句yield return item;。这个关键字其实是C#为迭代器模式提供的语法糖，它能让编译器自动帮你生成一个状态机类，省去手写IEnumerator接口的繁琐工作。要真正理解yield，得先从迭代器本身说起。
先搞清楚：迭代器和IEnumerator到底是什么关系
在.NET中，凡是能被foreach遍历的东西，本质上都实现了IEnumerable或IEnumerable<T>接口。这个接口只有一个核心方法GetEnumerator()，它返回一个IEnumerator对象。foreach循环的底层流程是这样的：先调用GetEnumerator拿到迭代器，然后反复调用MoveNext()方法前进，每次成功后通过Current属性取出当前元素，直到MoveNext返回false为止。
如果不用yield，你想让自己的类支持foreach，就得手动实现这一整套东西：一个实现IEnumerable的集合类，加上一个实现IEnumerator的迭代器类，里面要维护当前索引、处理边界情况、实现Reset方法。为一个简单的遍历功能写上大几十行样板代码，非常不划算。下面这个例子展示了传统写法的样子：
// 传统方式：手写迭代器，代码量巨大
public class NumberSequence : IEnumerable<int>
{
private int[] _data;
public NumberSequence(int[] data)
{
_data = data;
}
public IEnumerator<int> GetEnumerator()
{
return new NumberEnumerator(_data);
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
public class NumberEnumerator : IEnumerator<int>
{
private int[] _data;
private int _position = -1;
public NumberEnumerator(int[] data)
{
_data = data;
}
public int Current
{
get
{
if (_position < 0 || _position >= _data.Length)
throw new InvalidOperationException();
return _data[_position];
}
}
object System.Collections.IEnumerator.Current => Current;
public bool MoveNext() => ++_position < _data.Length;
public void Reset() => _position = -1;
public void Dispose() { }
}
这段代码只是为了包装一个int数组而已，就已经写了两类七方法。而如果使用yield，整个实现可以压缩成一个方法，功能完全等价。这就是yield存在的意义：它把迭代器的实现细节全部交给编译器。
yield return的工作原理：编译器背后的状态机
yield有两个用法：yield return用于逐个产出元素，yield break用于提前终止迭代。当编译器发现方法体里出现了yield return，它会做一件很神奇的事：把这个方法重写成一个实现IEnumerator接口的私有状态机类，你的局部变量会变成状态机的字段，每一条yield return语句对应一个状态标记。
来看一个最简单的对比，同样是遍历数组，用yield重写后变成这样：
public static IEnumerable<int> GetNumbers(int[] data)
{
foreach (int n in data)
{
// 每执行到这里，方法就暂停，把n交给调用方
yield return n;
}
}
// 调用方式
foreach (int n in GetNumbers(new[] { 1, 2, 3, 4, 5 }))
{
Console.WriteLine(n);
}
关键点在于：调用GetNumbers方法时，方法体并不会立即执行。它只是返回一个编译器生成的迭代器对象。真正的代码执行发生在foreach每次调用MoveNext的时候——每调用一次MoveNext，方法体就从上次暂停的位置恢复执行，直到遇到下一个yield return，把值交出去后再暂停。这种执行模式叫做延迟执行，也叫懒加载。
可以用一个小实验验证这一点。在方法入口处打印一行日志，你会发现这行日志在foreach开始之前根本不会输出：
public static IEnumerable<int> LazyDemo()
{
Console.WriteLine("方法开始执行"); // 不会被立即打印
yield return 1;
Console.WriteLine("产出1之后");
yield return 2;
}
var seq = LazyDemo(); // 此时不输出任何内容
Console.WriteLine("拿到迭代器了");
var list = seq.ToList(); // 此时才依次打印：方法开始执行 / 产出1之后
理解了暂停与恢复的机制，yield break的作用也就好懂了：它相当于让MoveNext直接返回false，结束整个迭代过程，类似普通方法里的return，只不过它结束的是迭代而不是方法调用本身。
yield的典型应用场景与实战示例
第一个经典场景是无限序列。因为yield是按需产出的，你完全可以写一个永不结束的序列，调用方拿多少算多少，不会有内存问题。比如生成斐波那契数列：
public static IEnumerable<long> Fibonacci()
{
long a = 0, b = 1;
while (true)
{
yield return a;
(a, b) = (b, a + b);
}
}
// 只取前10个，不会死循环
foreach (long n in Fibonacci().Take(10))
{
Console.WriteLine(n);
}
第二个场景是管线式数据处理。比如读取一个大文件时，逐行产出而不把整个文件加载进内存，这在处理日志文件、CSV导出等任务时特别实用：
public static IEnumerable<string> ReadLines(string path)
{
using var reader = new StreamReader(path);
string? line;
while ((line = reader.ReadLine()) != null)
{
yield return line;
}
}
// 组合使用：筛选包含错误的行，取前100条
var errors = ReadLines("app.log")
.Where(l => l.Contains("ERROR"))
.Take(100)
.ToList();
第三个场景是自定义遍历顺序。比如按层遍历一棵树，用yield写起来非常自然，代码结构清晰得接近伪代码：
public static IEnumerable<T> LevelOrder<T>(TreeNode<T> root) where T : notnull
{
if (root == null) yield break;
var queue = new Queue<TreeNode<T>>();
queue.Enqueue(root);
while (queue.Count > 0)
{
var node = queue.Dequeue();
yield return node.Value;
if (node.Left != null) queue.Enqueue(node.Left);
if (node.Right != null) queue.Enqueue(node.Right);
}
}
使用yield需要注意的几个坑
第一个坑是延迟执行带来的副作用陷阱。既然方法体在枚举时才执行，那么每次foreach都会重新执行一遍方法体。如果你在方法里做了数据库查询或者耗时计算，多次遍历结果就会多次查询。解决办法是在需要缓存结果的地方调用ToList()或ToArray()强制立即执行并物化结果。
第二个坑是参数校验时机。还是因为延迟执行，你在方法开头写的参数检查，要等到第一次MoveNext才会触发，调用方传了null可能当时不报错，遍历时才抛异常，排查起来很头疼。标准做法是把公开方法拆成两层：外层普通方法做校验，内层私有方法用yield：
public static IEnumerable<int> GetRange(int start, int count)
{
if (count < 0)
throw new ArgumentOutOfRangeException(nameof(count));
return GetRangeCore(start, count); // 立即抛出异常
}
private static IEnumerable<int> GetRangeCore(int start, int count)
{
for (int i = 0; i < count; i++)
yield return start + i;
}
第三个坑是yield return不能出现在try-catch块中（可以出现在try-finally的try里），这是语言层面的限制。此外，yield方法不能是匿名方法或包含ref返回，返回类型只能是IEnumerable、IEnumerator及其泛型版本。只要避开这些限制，yield就是C#里性价比最高的语法糖之一，用对了能让代码既简洁又高效。
C# yield迭代器yield return修改时间：2026-09-10 21:07:00