IEnumerable和IEnumerator接口

在开始研究实现现有.NET接口的过程之前，让我们首先看看的角色 IEnumerable和IEnumerator。回想一下，c#支持名为foreach的关键字，它允许您这样做 遍历任意数组类型的内容:

// Iterate over an array of items.
int[] myArrayOfInts = {10, 20, 30, 40};
foreach(int i in myArrayOfInts)
{
   Console.WriteLine(i);
}

虽然看起来只有数组类型可以使用这个构造，但事实是 任何支持名为GetEnumerator()方法的类型都可以由foreach构造求值。来 举例说明，跟我来!

假设我们有一个Garage类:

// Garage contains a set of Car objects.
public class Garage
{
   private Car[] carArray = new Car[4];
   // Fill with some Car objects upon startup.
   public Garage()
   {
      carArray[0] = new Car("Rusty", 30);
      carArray[1] = new Car("Clunker", 55);
      carArray[2] = new Car("Zippy", 30);
      carArray[3] = new Car("Fred", 30);
   }
}

理想情况下，使用foreach迭代Garage对象的子项会很方便 构造，就像一个数据值数组一样:

// This seems reasonable ...
public class Program
{
   static void Main(string[] args)
   {
      Console.WriteLine("***** Fun with IEnumerable / IEnumerator *****\n");
      Garage carLot = new Garage();
      // Hand over each car in the collection?
      foreach (Car c in carLot)
      {
         Console.WriteLine("{0} is going {1} MPH",
         c.PetName, c.CurrentSpeed);
      }
      Console.ReadLine();
   }
}

不幸的是，编译器告诉您Garage类没有实现名为 GetEnumerator()。该方法由IEnumerable接口形式化，该接口隐藏在系统中。集合名称空间。 支持此行为的类或结构宣称它们能够公开所包含的内容 调用者的子项(在本例中为foreach关键字本身)。下面是这个标准。net接口的定义:

// This interface informs the caller
// that the object's subitems can be enumerated.
public interface IEnumerable
{
   IEnumerator GetEnumerator();
}

如您所见，GetEnumerator()方法返回对另一个名为 System.Collections.IEnumerator。该接口提供了允许调用者遍历ienumerable兼容容器所包含的内部对象的基础结构:

// This interface allows the caller to
// obtain a container's subitems.
public interface IEnumerator
{
   bool MoveNext (); // Advance the internal position of the cursor.
   object Current { get;} // Get the current item (read-only property).
   void Reset (); // Reset the cursor before the first member.
}

如果您想要更新Garage类型以支持这些接口，那么您可能要走很长的路 手动实现每个方法。当然，您可以自由地提供自定义版本的 GetEnumerator()， MoveNext()， Current和Reset()，有一个更简单的方法。作为系统。数组类型(以及许多其他集合类)已经实现了IEnumerable和IEnumerator，您可以简单地将请求委托给系统。数组如下:

using System.Collections;
...
public class Garage : IEnumerable
{
   // System.Array already implements IEnumerator!
   private Car[] carArray = new Car[4];
   public Garage()
   {
      carArray[0] = new Car("FeeFee", 200);
      carArray[1] = new Car("Clunker", 90);
      carArray[2] = new Car("Zippy", 30);
      carArray[3] = new Car("Fred", 30);
   }
   public IEnumerator GetEnumerator()
   {
      // Return the array object's IEnumerator.
      return carArray.GetEnumerator();
   }
}

更新车库类型之后，就可以在c# foreach构造中安全地使用该类型了。此外，假定GetEnumerator()方法是公开定义的，对象用户也可以与IEnumerator类型交互:

// Manually work with IEnumerator.
IEnumerator i = carLot.GetEnumerator();
i.MoveNext();
Car myCar = (Car)i.Current;
Console.WriteLine("{0} is going {1} MPH", myCar.PetName, myCar.CurrentSpeed);

但是，如果您希望从对象级别隐藏IEnumerable的功能，只需使 使用显式接口实现:

IEnumerator IEnumerable.GetEnumerator()
{
  // Return the array object's IEnumerator.
  return carArray.GetEnumerator();
}

通过这样做，临时对象用户将不会找到Garage的GetEnumerator()方法，而 Foreach构造将在必要时在后台获取接口。

改编自Pro c# 5.0和。net 4.5框架

IEnumerable和IEnumerator(以及它们的泛型对应物IEnumerable<T>和IEnumerator<T>)是. net Framework类库集合中迭代器实现的基本接口。

IEnumerable是大多数代码中最常见的接口。它支持foreach循环，生成器(考虑yield)，由于它的小接口，它被用于创建紧密的抽象。IEnumerable依赖于IEnumerator。

另一方面，IEnumerator提供了一个稍低级别的迭代接口。它被称为显式迭代器，使程序员能够更好地控制迭代周期。

IEnumerable

IEnumerable是一个标准接口，支持对支持它的集合进行迭代(事实上，我现在能想到的所有集合类型都实现了IEnumerable)。编译器支持允许像foreach这样的语言特性。一般来说，它支持这个隐式迭代器实现。

foreach循环

foreach (var value in list)
  Console.WriteLine(value);

我认为foreach循环是使用IEnumerable接口的主要原因之一。foreach的语法非常简洁，与经典C风格的for循环相比非常容易理解，在经典C风格的for循环中，您需要检查各种变量来查看它在做什么。

生成的关键字

可能一个不太为人所知的特性是IEnumerable还通过使用yield return和yield break语句支持c#中的生成器。

IEnumerable<Thing> GetThings() {
   if (isNotReady) yield break;
   while (thereIsMore)
     yield return GetOneMoreThing();
}

抽象

实践中的另一个常见场景是使用IEnumerable来提供极简抽象。因为它是一个很小的只读接口，所以建议将集合公开为IEnumerable(而不是List)。这样你就可以在不破坏客户端代码的情况下自由更改实现(例如将List更改为LinkedList)。

问题

需要注意的一种行为是，在流实现中(例如，从数据库中逐行检索数据，而不是首先将所有结果加载到内存中)，您不能对集合进行多次迭代。这与List之类的内存集合相反，在List中可以迭代多次而不会出现问题。例如，ReSharper对IEnumerable的可能多个枚举进行了代码检查。

分子

另一方面，IEnumerator是使ienumble -foreach-magic工作的幕后接口。严格来说，它启用了显式迭代器。

var iter = list.GetEnumerator();
while (iter.MoveNext())
    Console.WriteLine(iter.Current);

根据我的经验，IEnumerator很少在常见场景中使用，因为它的语法比较冗长，语义有点混乱(至少对我来说是这样;例如，MoveNext()也返回一个值，这个名称根本不建议)。

IEnumerator的用例

我只在提供IEnumerable接口的库和框架中使用IEnumerator(级别稍低)。一个例子是数据流处理库，它在foreach循环中提供了一系列对象，即使在幕后数据是使用各种文件流和序列化收集的。

客户端代码

foreach(var item in feed.GetItems())
    Console.WriteLine(item);

图书馆

IEnumerable GetItems() {
    return new FeedIterator(_fileNames)
}

class FeedIterator: IEnumerable {
    IEnumerator GetEnumerator() {
        return new FeedExplicitIterator(_stream);
    }
}

class FeedExplicitIterator: IEnumerator {
    DataItem _current;

    bool MoveNext() {
        _current = ReadMoreFromStream();
        return _current != null;           
    }

    DataItem Current() {
        return _current;   
    }
}

我注意到了这些不同之处:

A.我们以不同的方式迭代列表，foreach可用于IEnumerable, while loop可用于IEnumerator。

B.当我们从一个方法传递到另一个方法时，IEnumerator可以记住当前索引(它开始使用当前索引)，但IEnumerable不能记住索引，它将索引重置为开始。更多内容请参见https://www.youtube.com/watch?v=jd3yUjGc9M0

实现IEnumerable意味着你的类返回一个IEnumerator对象:

public class People : IEnumerable
{
    IEnumerator IEnumerable.GetEnumerator()
    {
        // return a PeopleEnumerator
    }
}

实现IEnumerator意味着你的类返回迭代的方法和属性:

public class PeopleEnumerator : IEnumerator
{
    public void Reset()...

    public bool MoveNext()...

    public object Current...
}

这就是区别所在。

实现IEnumerable可以让你获得一个列表的IEnumerator。

IEnumerator允许使用yield关键字以foreach样式顺序访问列表中的项。

在foreach实现之前(例如在Java 1.4中)，迭代列表的方法是从列表中获取一个枚举器，然后向它请求列表中的“下一个”项，只要作为下一个项返回的值不为空。Foreach只是隐式地将其作为一种语言特性来实现，与lock()在幕后实现Monitor类的方式相同。

我期望foreach工作在列表上，因为它们实现了IEnumerable。

IEnumerable和IEnumerator的区别:

IEnumerable内部使用IEnumerator。 IEnumerable不知道哪个项目/对象正在执行。 无论何时将IEnumerator传递给另一个函数，它都知道项/对象的当前位置。 当我们将IEnumerable集合传递给另一个函数时，它 不知道项目/对象的当前位置(不知道正在执行哪个项目) IEnumerable有一个方法GetEnumerator()

public interface IEnumerable<out T>: IEnumerable ｛ IEnumerator < T > GetEnumerator (); ｝

IEnumerator有一个名为Current的属性和两个方法，Reset()和MoveNext()(这对于了解列表中项目的当前位置非常有用)。

public interface IEnumerator
{
     object Current { get; }
     bool MoveNext();
     void Reset();
}