根据Albahari 兄弟 [Page No.273]的说法，之所以使用，IEnumerable是因为：
通过定义返回枚举器的单个方法，IEnumerable提供了灵活性，即
->迭代逻辑可以framed off to another class（理解）
-> Moreover it means that several consumers can enumerate the collection at once without interfering with each other（不明白）
我无法理解第二点！
如何IEnumerable不使用IEnumerator启用多个消费者一次枚举集合？
IEnumerable实现一个方法，GetEnumerator()，它返回一个IEnumerator. 因为每次调用该方法时，IEnumerator都会返回一个新的，它有自己的状态。这样，多个线程可以迭代同一个集合，而不会有一个线程更改另一个线程的当前指针的危险。
如果一个集合实现了IEnumerator，那么它一次只能被一个线程有效地迭代。考虑以下代码：
public class EnumeratorList : IEnumerator
{
private object[] _list = new object[10];
private int _currentIndex = -1;
public object Current { get { return _list[_currentIndex] } };
public bool MoveNext()
{
return ++_currentIndex < 10;
}
public void Reset()
{
_currentIndex = -1;
}
}
鉴于该实现，如果两个线程尝试同时遍历 EnumeratorList，它们将得到交错的结果，并且不会看到整个列表。
如果我们将其重构为IEnumerable，则多个线程可以访问同一个列表而不会出现此类问题。
public class EnumerableList : IEnumerable
{
private object[] _list = new object[10];
public IEnumerator GetEnumerator()
{
return new ListEnumerator(this);
}
private object this[int i]
{
return _list[i];
}
private class ListEnumerator : IEnumerator
{
private EnumeratorList _list;
private int _currentIndex = -1;
public ListEnumerator(EnumeratorList list)
{
_list = list;
}
public object Current { get { return _list[_currentIndex] } };
public bool MoveNext()
{
return ++_currentIndex < 10;
}
public void Reset()
{
_currentIndex = -1;
}
}
}
现在这是一个简单的、人为的例子，当然，但我希望这有助于使它更清楚。
实现的类型IEnumerator必须具有方法和属性，以便您可以对其进行迭代，即MoveNext()、Reset()和Current。如果你有多个线程同时尝试迭代这个对象会发生什么？MoveNext()当它们都调用相同的函数时，它们会互相踩踏，这会修改相同的Current属性。
实现的类型IEnumerable必须能够提供IEnumerator. 现在当多个线程迭代对象时会发生什么？每个线程都有一个单独的 IEnumerator 对象实例。返回的 IEnumerator 与您的集合的对象类型不同。它们是完全不同的东西。但是，它们确实知道如何获取下一个项目并显示集合的当前项目，并且每个对象都将拥有自己的有关当前枚举状态的内部数据。因此，它们不会互相踩踏并安全地从单独的线程迭代您的集合。
有时，集合类型会为自己实现 IEnumerator（它是它自己的枚举器），然后通过返回自身来实现 IEnumerable。在这种情况下，对于多个线程，您将一无所获，因为它们仍然使用同一个对象进行枚举。这是倒退。相反，正确的过程是首先为您的集合实现一个单独的（可以嵌套的）枚举器类型。然后，您通过返回该类型的新实例来实现 IEnumerable，并通过保留私有实例来实现 IEnumerator。
考虑代码：
class Program
{
static void Main(string[] args)
{
var test = new EnumTest();
test.ConsumeEnumerable2Times();
Console.ReadKey();
}
}
public class EnumTest
{
public IEnumerable<int> CountTo10()
{
for (var i = 0; i <= 10; i++)
yield return i;
}
public void ConsumeEnumerable2Times()
{
var enumerable = CountTo10();
foreach (var n in enumerable)
{
foreach (int i in enumerable)
{
Console.WriteLine("Outer: {0}, Inner: {1}", n, i);
}
}
}
}
此代码将产生输出：
Outer: 0, Inner: 1
Outer: 0, Inner: 2
...
Outer: 1, Inner: 0
Outer: 1, Inner: 1
...
Outer: 10, Inner: 10
使用 IEnumerable 您可以一遍又一遍地枚举同一个集合。IEnumerable 实际上将为每个枚举请求返回一个新的 IEnumerator 实例。
在上面的示例中，方法 EnumTest() 被调用一次，但返回的 IEnumerable 被使用了 2 次。每次独立数到 10。
这就是为什么“几个消费者可以一次枚举集合而不会相互干扰”。您可以将相同的 IEnumerable 对象传递给 2 个方法，它们将独立枚举集合。使用 IEnumerator 你无法做到这一点。
对不起我的英语。