C# IEnumerable ，IEnumerator 与 foreach，何时使用什么
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/1085638/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
IEnumerable , IEnumerator vs foreach, when to use what
提问by Wondering
I was going through IEnumerable and IEnumerator , but could not get one point clearly..if we have foreach, then why do we need this two interfaces? Is there any scenario where we have to use interfaces.If yes, then can somebody explain with an example. Any suggestions and remarks are welcome. Thanks.
我正在浏览 IEnumerable 和 IEnumerator ，但无法清楚地得到一分。如果我们有 foreach，那为什么我们需要这两个接口？有没有我们必须使用接口的场景。如果是，那么有人可以用例子解释一下。欢迎任何建议和意见。谢谢。
采纳答案by Jon Skeet
foreachusesthe interfaces in many cases. You need the interfaces if you want to implementa sequence which foreachcan then use. (Iterator blocks usually make this implementation task very simple though.)
foreach在许多情况下使用接口。如果您想实现一个foreach可以使用的序列，则需要这些接口。（尽管迭代器块通常使这个实现任务非常简单。）
However, just occasionallyit can be useful to use the iterators directly. A good example is when trying to "pair up" two different sequences. For example, suppose you receive two sequences - one of names, one of ages, and you want to print the two together. You might write:
但是，偶尔直接使用迭代器会很有用。一个很好的例子是试图“配对”两个不同的序列。例如，假设您收到两个序列 - 一个是姓名，一个是年龄，并且您想将这两个序列打印在一起。你可能会写：
static void PrintNamesAndAges(IEnumerable<string> names, IEnumerable<int> ages)
{
using (IEnumerator<int> ageIterator = ages.GetEnumerator())
{
foreach (string name in names)
{
if (!ageIterator.MoveNext())
{
throw new ArgumentException("Not enough ages");
}
Console.WriteLine("{0} is {1} years old", name, ageIterator.Current);
}
if (ageIterator.MoveNext())
{
throw new ArgumentException("Not enough names");
}
}
}
Likewise it can be useful to use the iterator if you want to treat (say) the first item differently to the rest:
同样，如果您想将第一项与其余项区别对待（例如），则使用迭代器会很有用：
public T Max<T>(IEnumerable<T> items)
{
Comparer<T> comparer = Comparer<T>.Default;
using (IEnumerator<T> iterator = items.GetEnumerator())
{
if (!iterator.MoveNext())
{
throw new InvalidOperationException("No elements");
}
T currentMax = iterator.Current;
// Now we've got an initial value, loop over the rest
while (iterator.MoveNext())
{
T candidate = iterator.Current;
if (comparer.Compare(candidate, currentMax) > 0)
{
currentMax = candidate;
}
}
return currentMax;
}
}
Now, if you're interested in the difference between IEnumerator<T>and IEnumerable<T>, you might want to think of it in database terms: think of IEnumerable<T>as a table, and IEnumerator<T>as a cursor. You can ask a table to give you a new cursor, and you can have multiple cursors over the same table at the same time.
现在，如果您对IEnumerator<T>和之间的区别感兴趣IEnumerable<T>，您可能想用数据库术语来考虑它：将其IEnumerable<T>视为表和IEnumerator<T>游标。你可以要求一个表给你一个新的游标，你可以同时在同一个表上有多个游标。
It can take a while to really grok this difference, but just remembering that a list (or array, or whatever) doesn't have any concept of "where you are in the list" but an iterator over that list/array/whatever doeshave that bit of state is helpful.
真正理解这种差异可能需要一段时间，但只要记住列表（或数组或其他任何东西）没有任何“您在列表中的位置”的概念，而是该列表/数组上的迭代器/无论做什么有那种状态是有帮助的。
回答by Gishu
What Jon said.
乔恩说的。
IEnumerableorIEnumerable<T>: by implementing this an object states that it can give you an iterator that you can use to traverse over the sequence/collection/setIEnumeratororIEnumerator<T>: if you call the GetEnumerator method defined in the previous interface, you get an iterator object as an IEnumerator reference. This enables you to call MoveNext() and get the Current object.foreach: is a C# construct/facade in a sense in that you don't need to know how it works under the hood. It internally gets the iterator and calls the right methods for you to concentrate on what you want to do with each item (the contents of the foreach block). Most of the time, you'd just need foreach unless you're implementing your own type or custom iteration, in which case you'd need to get to know the first 2 interfaces.
IEnumerable或者IEnumerable<T>：通过实现这个，一个对象声明它可以给你一个迭代器，你可以用它来遍历序列/集合/集合IEnumerator或者IEnumerator<T>：如果调用之前接口中定义的 GetEnumerator 方法，则会得到一个迭代器对象作为 IEnumerator 引用。这使您能够调用 MoveNext() 并获取 Current 对象。foreach: 在某种意义上是 C# 构造/外观，因为您不需要知道它在幕后是如何工作的。它在内部获取迭代器并调用正确的方法让您专注于您想要对每个项目（foreach 块的内容）执行的操作。大多数情况下，除非您要实现自己的类型或自定义迭代，否则您只需要 foreach，在这种情况下，您需要了解前 2 个接口。
回答by thecoop
Bear in mind that you don't haveto implement IEnumerator and varients thereof to use foreach - IIRC, all it needs is a GetEnumerator() method that returns an object that has a MoveNext() method returning a bool, and a Current property returning an object. You don't need to use IEnumerator and IEnumerable, although it generally is a very good idea to do so. See herefor more information.
记住，你不具备实施的IEnumerator及其一些变体来使用的foreach - IIRC，它需要的只是一个的GetEnumerator（）方法返回一个对象具有的MoveNext（）方法返回一个布尔值，和当前的财产返还一个东西。您不需要使用 IEnumerator 和 IEnumerable，尽管这样做通常是一个很好的主意。请参阅此处了解更多信息。
