C#中的foreach是如何实现的？ [复制]

Question

foreach 究竟是如何在 C# 中实现的？

我想象它的一部分看起来像：

var enumerator = TInput.GetEnumerator();
while(enumerator.MoveNext())
{
  // do some stuff here
}

但是我不确定到底发生了什么。每个周期使用什么方法返回enumerator.Current？它是返回 [for each cycle] 还是需要匿名函数或其他东西来执行 foreach 的主体？

Answer 1

惊讶于没有触及确切的实现。虽然您在问题中发布的是最简单的形式，但完整的实现（包括枚举器处理、强制转换等）在 8.8.4 section of the spec.

现在有两种情况可以在一个类型上运行 foreach 循环：

1. 如果该类型有一个名为 GetEnumerator 的公共/非静态/非泛型/无参数方法，则该方法返回具有公共 MoveNext 方法和公共 Current 属性的内容。 As noted by Mr Eric Lippert in this blog article，这是为了适应前通用时代的类型安全和在值类型的情况下与装箱相关的性能问题。请注意，这是 duck 打字 的情况。例如这有效：

   class Test
   {
       public SomethingEnumerator GetEnumerator()
       {
   
       }
   }
   
   class SomethingEnumerator
   {
       public Something Current //could return anything
       {
           get { return ... }
       }
   
       public bool MoveNext()
       {
   
       }
   }
   
   //now you can call
   foreach (Something thing in new Test()) //type safe
   {
   
   }
   

   然后编译器将其翻译为：

   E enumerator = (collection).GetEnumerator();
   try {
      ElementType element; //pre C# 5
      while (enumerator.MoveNext()) {
         ElementType element; //post C# 5
         element = (ElementType)enumerator.Current;
         statement;
      }
   }
   finally {
      IDisposable disposable = enumerator as System.IDisposable;
      if (disposable != null) disposable.Dispose();
   }
   

2. 如果类型实现了IEnumerable，其中GetEnumerator 返回IEnumerator，它具有公共MoveNext 方法和公共Current 属性。 但一个有趣的子情况是，即使如果你明确实现IEnumerable（即Test 类上没有公共GetEnumerator 方法），你可以有一个foreach。

   class Test : IEnumerable
   {
       IEnumerator IEnumerable.GetEnumerator()
       {
   
       }
   }
   

   这是因为在这种情况下foreach 被实现为（假设类中没有其他公共GetEnumerator 方法）：

   IEnumerator enumerator = ((IEnumerable)(collection)).GetEnumerator();
   try {
       ElementType element; //pre C# 5
       while (enumerator.MoveNext()) {
           ElementType element; //post C# 5
           element = (ElementType)enumerator.Current;
           statement;
      }
   }
   finally {
       IDisposable disposable = enumerator as System.IDisposable;
       if (disposable != null) disposable.Dispose();
   }
   

   如果该类型显式实现了IEnumerable<T>，则foreach 被转换为（假设类中没有其他公共GetEnumerator 方法）：

   IEnumerator<T> enumerator = ((IEnumerable<T>)(collection)).GetEnumerator();
   try {
       ElementType element; //pre C# 5
       while (enumerator.MoveNext()) {
           ElementType element; //post C# 5
           element = (ElementType)enumerator.Current; //Current is `T` which is cast
           statement;
      }
   }
   finally {
       enumerator.Dispose(); //Enumerator<T> implements IDisposable
   }
   

---

需要注意的一些有趣的事情是：

1. 在上述两种情况下，Enumerator 类都应该有一个公共的MoveNext 方法和一个公共的Current 属性。换句话说，如果你正在实现IEnumerator 接口，它必须被隐式实现。例如，foreach 不适用于这个枚举器：

   public class MyEnumerator : IEnumerator
   {
       void IEnumerator.Reset()
       {
           throw new NotImplementedException();
       }
   
       object IEnumerator.Current
       {
           get { throw new NotImplementedException(); }
       }
   
       bool IEnumerator.MoveNext()
       {
           throw new NotImplementedException();
       }
   }
   

   （感谢 Roy Namir 指出这一点。foreach 实现并不像表面上看起来那么容易）

2. 枚举器优先级 - 如果你有一个public GetEnumerator 方法，那么这是foreach 的默认选择，无论谁在实现它。例如：

   class Test : IEnumerable<int>
   {
       public SomethingEnumerator GetEnumerator()
       {
           //this one is called
       }
   
       IEnumerator<int> IEnumerable<int>.GetEnumerator()
       {
   
       }
   }
   

   如果您没有公共实现（即只有显式实现），则优先级类似于 IEnumerator<T> > IEnumerator。

3. 在foreach 的实现中涉及一个转换运算符，其中集合元素被转换回类型（在foreach 循环本身中指定）。这意味着即使您像这样写了SomethingEnumerator：

   class SomethingEnumerator
   {
       public object Current //returns object this time
       {
           get { return ... }
       }
   
       public bool MoveNext()
       {
   
       }
   }
   

   你可以写：

   foreach (Something thing in new Test())
   {
   
   }
   

   因为Something 与object 类型兼容，遵循C# 规则，或者换句话说，如果两种类型之间可能存在显式转换，编译器就会允许它。否则编译器会阻止它。实际的转换是在运行时执行的，可能会失败也可能不会失败。

Answer 2

它不使用匿名函数，不。基本上，编译器会将代码转换为与您在此处显示的 while 循环大致等效的内容。

foreach 不是函数调用——它是语言本身的内置函数，就像for 循环和while 循环一样。它不需要返回任何东西或“获取”任何类型的功能。

请注意，foreach 有一些有趣的皱纹：

• 在迭代数组时（在编译时已知），编译器可以使用循环计数器并与数组的长度进行比较，而不是使用IEnumerator
• foreach 将在最后处理迭代器；这对于扩展IDisposable 的IEnumerator<T> 来说很简单，但是由于IEnumerator 不，编译器会插入一个检查以在执行时测试迭代器是否实现IDisposable
• 您可以迭代未实现IEnumerable 或IEnumerable<T> 的类型，只要您有一个适用的GetEnumerator() 方法，该方法返回一个具有合适Current 和MoveNext() 成员的类型。正如在 cmets 中所指出的，一个类型也可以显式地实现 IEnumerable 或 IEnumerable<T>，但有一个公共的 GetEnumerator() 方法，它返回的类型不是 IEnumerator/IEnumerator<T>。有关示例，请参见 List<T>.GetEnumerator() - 这避免了在许多情况下不必要地创建引用类型对象。

有关详细信息，请参阅 C# 4 规范的第 8.8.4 节。