实际场景中为何需要迭代器？以斐波那契实现为例

我完全懂你的困惑——直接写个普通方法算斐波那契数明明能搞定，为啥还要费劲写迭代器？其实迭代器的价值不在于“能完成任务”，而在于怎么完成任务，尤其是在处理无限序列、内存敏感场景或者需要按需计算的时候，优势就直接凸显出来了。

1. 无限序列的天然解决方案 #

斐波那契数列本身是无限的，你用普通方法的话，要么得提前指定要生成多少项，要么生成的列表会无限膨胀占满内存。但迭代器是按需生成的——每次foreach循环到下一项，才会计算下一个斐波那契数，永远不会一次性把所有数都存在内存里。

对比两种实现：

普通方法（返回列表） #

static List<int> GetFibonacci(int count)
{
    var fibs = new List<int> { 0, 1 };
    for (int i = 2; i < count; i++)
    {
        fibs.Add(fibs[i-1] + fibs[i-2]);
    }
    return fibs;
}

这个方法必须提前知道要多少项，要是count设成100万，那列表会直接占用大量内存，甚至可能撑爆内存。

迭代器实现 #

static IEnumerable<int> FibonacciIterator()
{
    int a = 0, b = 1;
    yield return a;
    yield return b;
    while (true)
    {
        int c = a + b;
        yield return c;
        a = b;
        b = c;
    }
}

这个迭代器可以无限生成斐波那契数，你想取多少就取多少，比如：

foreach (int fib in FibonacciIterator().Take(10))
{
    Console.WriteLine(fib);
}

这里只会生成前10项，内存里永远只存当前和前两个数，完全不会有内存压力。

2. 懒加载+状态保留，适配动态场景 #

假设你做了个小工具，用户点击“下一个”按钮才显示下一个斐波那契数。用普通方法的话，你要么提前生成一堆数存在内存里，要么每次点击都重新计算前面所有项（效率极低）。但迭代器会帮你保存当前的计算状态，每次调用MoveNext()时才计算下一项，完美适配这种按需触发的场景。

比如UI里的实现：

var fibEnumerator = FibonacciIterator().GetEnumerator();

// 用户点击按钮时执行
private void NextButton_Click(object sender, EventArgs e)
{
    if (fibEnumerator.MoveNext())
    {
        CurrentFibLabel.Text = fibEnumerator.Current.ToString();
    }
}

这里迭代器自动帮你记住了上一次的a和b的值，不用每次都从头算，也不用提前存一堆数占内存。

3. 和LINQ无缝配合，代码更简洁 #

迭代器实现的IEnumerable<T>可以直接和LINQ方法结合，比如过滤、取前N项、筛选条件等，代码会非常清爽。比如你想取所有小于1000的偶数斐波那契数：

var evenFibsUnder1000 = FibonacciIterator()
                          .Where(fib => fib % 2 == 0)
                          .TakeWhile(fib => fib < 1000);
foreach (var fib in evenFibsUnder1000)
{
    Console.WriteLine(fib);
}

要是用普通方法，你得先生成一堆数，再手动过滤，不仅占内存，代码也会繁琐很多。

4. 非内置集合的真实案例：超大文件逐行读取 #

再给你一个完全脱离内置集合的实用案例：读取几GB的超大日志文件，逐行处理。如果用普通方法把所有行读到列表里，直接就会内存溢出，但迭代器可以完美解决：

static IEnumerable<string> ReadLargeLogFile(string filePath)
{
    using (var reader = new StreamReader(filePath))
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            yield return line;
        }
    }
}

这个迭代器每次只读取一行日志，处理完就释放，内存占用极低，就算是10GB的日志文件也能轻松处理。

最后总结一下 #

迭代器的核心价值是按需生成、状态保留、低内存占用——它不是为了完成“本来就能做的事”，而是为了更高效、更灵活地完成事，尤其是在处理无限序列、超大数据或者需要动态计算的场景中，普通方法根本没法替代。

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