C#的迭代器是什么？如何使用？

来源：这里教程网时间：2026-02-21 17:23:56 作者：

C#的迭代器是一种特殊的方法，它允许你以顺序访问的方式遍历集合对象（例如列表、数组）中的元素，而无需了解底层集合的内部结构。它本质上是一个状态机，记住当前的位置并提供

MoveNext()

和

Current

属性来控制迭代过程。

迭代器通过

yield return

语句来实现，它在每次迭代时返回一个值，并在下次请求时从上次停止的地方继续执行。这使得迭代器非常适合处理大型数据集，因为它只在需要时才生成值，从而节省内存。

解决方案

要使用C#中的迭代器，你需要遵循以下步骤：

创建一个迭代器方法： 迭代器方法必须返回
IEnumerable<T>
或
IEnumerator<T>
接口，其中
T
是集合中元素的类型。

使用
yield return
语句： 在迭代器方法中使用
yield return
语句来逐个返回集合中的元素。
yield break
语句用于提前结束迭代。

调用迭代器方法： 调用迭代器方法会返回一个迭代器对象，你可以使用
foreach
循环或手动调用
MoveNext()
和
Current
属性来遍历集合。

下面是一个简单的例子，展示了如何使用迭代器来遍历一个整数列表：

using System;
using System.Collections.Generic;
public class Example
{
    public static IEnumerable<int> GetNumbers(int count)
    {
        for (int i = 0; i < count; i++)
        {
            yield return i;
        }
    }
    public static void Main(string[] args)
    {
        foreach (int number in GetNumbers(5))
        {
            Console.WriteLine(number);
        }
    }
}

在这个例子中，

GetNumbers

方法是一个迭代器方法，它返回一个

IEnumerable<int>

接口。

yield return i;

语句在每次迭代时返回一个整数。

Main

方法使用

foreach

循环来遍历迭代器返回的整数序列。

如何自定义迭代器类，而不仅仅是方法？

除了使用

yield return

在方法中创建迭代器，你还可以实现

IEnumerable<T>

和

IEnumerator<T>

接口来创建自定义迭代器类。这样做提供了更大的灵活性，允许你完全控制迭代过程。

举个例子，假设我们需要创建一个迭代器，它以相反的顺序遍历一个数组。我们可以这样实现：

using System;
using System.Collections;
using System.Collections.Generic;
public class ReverseArrayIterator<T> : IEnumerable<T>, IEnumerator<T>
{
    private T[] _array;
    private int _position;
    private bool _disposed = false;
    public ReverseArrayIterator(T[] array)
    {
        _array = array;
        _position = array.Length; // Start from the end
    }
    public T Current
    {
        get
        {
            if (_position >= _array.Length || _position < 0)
            {
                throw new InvalidOperationException("Invalid position");
            }
            return _array[_position];
        }
    }
    object IEnumerator.Current => Current;
    public void Dispose()
    {
        _disposed = true;
    }
    public bool MoveNext()
    {
        if (_disposed) return false;
        _position--;
        return _position >= 0;
    }
    public void Reset()
    {
        _position = _array.Length;
    }
    public IEnumerator<T> GetEnumerator()
    {
        return this;
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}
public class Example
{
    public static void Main(string[] args)
    {
        string[] names = { "Alice", "Bob", "Charlie" };
        ReverseArrayIterator<string> iterator = new ReverseArrayIterator<string>(names);
        foreach (string name in iterator)
        {
            Console.WriteLine(name); // Output: Charlie Bob Alice
        }
    }
}

这个例子展示了如何实现

IEnumerable<T>

和

IEnumerator<T>

接口来创建一个自定义迭代器类。需要注意的是，

Reset()

方法在实际应用中可能并不总是可靠的，因为它依赖于集合的底层状态。在某些情况下，可能需要创建一个新的迭代器实例。

迭代器在LINQ中的作用是什么？

迭代器在LINQ（Language Integrated Query）中扮演着至关重要的角色。 LINQ 扩展方法（例如

Where

Select

OrderBy

）通常返回

IEnumerable<T>

接口，这意味着它们实际上返回的是迭代器。

考虑以下 LINQ 查询：

using System;
using System.Collections.Generic;
using System.Linq;
public class Example
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
        IEnumerable<int> evenNumbers = numbers.Where(n => n % 2 == 0);
        // The evenNumbers variable is an iterator. No actual filtering has happened yet.
        foreach (int number in evenNumbers)
        {
            Console.WriteLine(number); // Filtering happens here, when the iterator is enumerated.
        }
    }
}

在这个例子中，

Where

方法返回一个迭代器，它只在

foreach

循环开始时才真正开始筛选数字。这种延迟执行（也称为“惰性求值”）是 LINQ 的一个关键特性，它允许你构建复杂的查询，而无需立即执行所有操作。只有当你实际需要结果时，才会执行查询。这可以显著提高性能，特别是对于大型数据集。

如何处理迭代器中的异常？

在迭代器方法中处理异常需要特别小心。如果迭代器方法抛出一个异常，

foreach

循环会立即终止，并且可能无法完全遍历集合。

有几种方法可以处理迭代器中的异常：

在迭代器方法内部处理异常： 这是最常见的方法。你可以使用
try-catch
块来捕获异常，并采取适当的措施，例如记录错误或跳过当前元素。

在调用迭代器方法的代码中处理异常： 你也可以在调用迭代器方法的代码中使用
try-catch
块来捕获异常。但是，这种方法只能捕获迭代器方法在第一次调用
MoveNext()
方法时抛出的异常。

使用
finally
块来清理资源： 如果你的迭代器方法使用了任何资源（例如文件或数据库连接），你应该使用
finally
块来确保这些资源在迭代器方法结束时得到释放。

以下是一个例子，展示了如何在迭代器方法内部处理异常：

using System;
using System.Collections.Generic;
public class Example
{
    public static IEnumerable<int> GetNumbers(int count)
    {
        for (int i = 0; i < count; i++)
        {
            try
            {
                if (i == 3)
                {
                    throw new Exception("Something went wrong!");
                }
                yield return i;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
                // You might want to log the error or take other appropriate action here.
            }
        }
    }
    public static void Main(string[] args)
    {
        foreach (int number in GetNumbers(5))
        {
            Console.WriteLine(number);
        }
    }
}

在这个例子中，如果

等于 3，迭代器方法会抛出一个异常。

try-catch

块捕获这个异常，并打印一条错误消息。迭代器方法然后继续执行，并返回剩余的数字。

关键在于，即使发生异常，迭代器仍然可以继续执行，这避免了完全中断迭代过程。当然，具体如何处理异常取决于你的应用程序的需求。

迭代器和状态管理：深入理解 yield return 的机制

yield return

的强大之处在于它能够维护迭代器方法的状态。每次调用

yield return

时，方法的状态（包括局部变量、循环计数器和任何其他状态信息）都会被保存。当下次调用

MoveNext()

时，方法会从上次停止的地方继续执行，恢复之前保存的状态。

这使得迭代器非常适合处理复杂的状态转换和生成复杂的序列。例如，你可以使用迭代器来实现一个状态机，或者生成一个斐波那契数列。

using System;
using System.Collections.Generic;
public class FibonacciSequence
{
    public static IEnumerable<int> Generate(int n)
    {
        int a = 0;
        int b = 1;
        for (int i = 0; i < n; i++)
        {
            yield return a;
            int temp = a;
            a = b;
            b = temp + b;
        }
    }
    public static void Main(string[] args)
    {
        foreach (int number in Generate(10))
        {
            Console.WriteLine(number);
        }
    }
}

在这个例子中，