When I emplement IEnumerable<T>
interface I see two GetEnumerator
methods: one returning IEnumerator
and other IEnumerator<T>
. When would I use one or another?
If you are implementing the IEnumerable<T>
generic interface, you will pretty much always have to use the generic GetEnumerator method - unless you cast your object explicitly to (non-generic) IEnumerable.
The reason is backwards compatability with .NET 1.0/1.1 which didn't support generics.
You usually implement both. One is the newer, generic version that returns a typesafe enumerator (IEnumerator<T>
). The other one is for compatibility with Legacy code (returns IEnumerator
). A typical implementation is:
public IEnumerator<T> GetEnumerator() {
foreach(T item in items) {
yield return item;
}
}
IEnumerator IEnumerable.GetEnumerator() {
return GetEnumerator();
}
The reason there are two methods is because IEnumerable<T>
inherits the IEnumerable
interface so you are seeing the generic method from IEnumerable<T>
and the non-generic method from IEnumerable
.
Here is how you want to implement the interface in your type:
class Foo : IEnumerable<Foo>
{
public IEnumerator<Foo> GetEnumerator()
{
// do your thing here
}
// do a EIMI here and simply call the generic method
IEnumerator IEnumerable.GetEnumerator()
{
this.GetEnumerator();
}
}
Usually GetEnumerator()
calls GetEnumerator<T>()
, so there should not be much difference in behavior. As for why there are two methods, this is done for backwards compatibility and for use in situation where T
is not of great interest (or is just unknown).
The one is generic, the other one not. I believe the compiler prefers to use the generic overload.
来源:https://stackoverflow.com/questions/560678/ienumerablet-provides-two-getenumerator-methods-what-is-the-difference-betwe