17370845950

答案：foreach通过IEnumerable和IEnumerator实现迭代，编译器将其转为调用GetEnumerator()、MoveNext()和Current的循环结构，using确保资源释放。

在C#中，foreach 循环是遍历集合最常用的方式之一。它简洁、安全且不易出错。但你是否好奇过，foreach 内部是如何工作的？它的底层原理依赖于两个核心接口：IEnumerable 和 IEnumerator。下面我们深入解析这两个接口的作用以及 foreach 是如何利用它们实现迭代的。

IEnumerable 接口：提供迭代能力

IEnumerable 接口定义了一个方法：

这个接口的作用是“我可以被遍历”。任何实现了 IEnumerable 的类型（如数组、List、Dictionary 等）都表明它支持逐个访问其元素。

当你在 foreach 中使用一个集合时，编译器首先检查该类型是否实现了 IEnumerable 或泛型版本 IEnumerable。如果实现了，就会调用其 GetEnumerator() 方法获取一个迭代器对象。

IEnumerator 接口：执行实际遍历

IEnumerator 才是真正控制“当前指向哪个元素”的对象。它包含三个关键成员：

• object Current { get; }：获取当前指向的元素。
• bool MoveNext()：将游标移动到下一个元素。如果有下一个元素，返回 true；否则返回 false。
• void Reset()：将游标重置到起始位置（很少使用，某些情况下会抛出异常）。

在遍历过程中，foreach 会不断调用 MoveNext() 来推进位置，并在每次成功后读取 Current 的值。

foreach 编译后的等效代码

C# 编译器会将 foreach 循环转换为基于 IEnumerator 的手动迭代过程。例如，下面这段代码：

会被编译成类似这样的结构：

注意这里使用了 using 语句。这是因为大多数集合的枚举器实现了 IDisposable 接口。比如在 LINQ 查询中，枚举器可能持有资源（如数据库连接或文件流），需要及时释放。using 确保了即使发生异常，也能正确调用 Dispose()。

自定义可枚举类型示例

我们可以自己实现 IEnumerable 和 IEnumerator 来创建支持 foreach 的类：

public class NumberSequence : IEnumerable
{
   private int start, count;

   public NumberSequence(int start, int count)
   {
      this.start = start;
      this.count = count;
   }

   public IEnumerator GetEnumerator()
   {
      return new NumberEnumerator(start, count);
   }

   IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

private class NumberEnumerator : IEnumerator
{
   private int current;
   private int start, count, index;

   public NumberEnumerator(int start, int count)
   {
      this.start = start;
      this.count = count;
      this.index = -1; // 初始位置在第一个元素之前
   }

   public int Current => current;

   object IEnumerator.Current => Current;

   public bool MoveNext()
   {
      if (index       {
         index++;
         current = start + index;
         return true;
      }
      return false;
   }

   public void Reset() => index = -1;

   public void Dispose() { } // 无资源需要释放
}

这样我们就可以直接使用 foreach 遍历这个序列：

基本上就这些。理解 IEnumerable 与 IEnumerator 的协作机制，有助于我们写出更高效、更可控的集合操作代码，也能更好地掌握 LINQ、延迟执行等高级特性背后的逻辑。不复杂但容易忽略。