IEnumerable 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?

score 34 · Answer 1 · edited Aug 12 '15 at 09:49

34

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

edited Aug 12 '15 at 09:49

davmos

9,324
4
40
43

answered Feb 18 '09 at 11:33

this one helped me a lot, avoiding the extra-class for the nested enumerator! – Nov 25 '09 at 07:17
+1. I also was googling to find a reference implementation that avoids the nested enumerator class and this was the first answer I came to. – quentin-starin Jul 20 '10 at 18:49

score 13 · Answer 2 · edited Aug 12 '15 at 09:50

13

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

edited Aug 12 '15 at 09:50

davmos

9,324
4
40
43

answered Feb 18 '09 at 11:33

Andrew Hare

344,730
71
640
635

+1 - EIMI = Explicit interface member implementation – P.Brian.Mackey Nov 21 '13 at 20:42
But how on earth `Foo : IEnumerable` makes sense? – nawfal Dec 01 '13 at 02:53

score 8 · Accepted Answer · answered Feb 18 '09 at 11:33

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.

score 4 · Answer 4 · answered Feb 18 '09 at 11:32

4

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

answered Feb 18 '09 at 11:32

Anton Gogolev

113,561
39
200
288

score 2 · Answer 5 · answered Feb 18 '09 at 11:31

2

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

answered Feb 18 '09 at 11:31

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

5 Answers5

Linked