IEnumerable<T> provides two GetEnumerator methods - what is the difference between them?

Question

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?

Answer 1

The one is generic, the other one not. I believe the compiler prefers to use the generic overload.

Answer 2

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).

Answer 3

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();
    }
}

Answer 4

You usually implement both. One is the newer, generic version that returns a typesafe enumerator (IEnumerator) 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();
    }

Answer 5

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.