Question

I assume the following sample gives a best practice that we should follow when we implement the IEnumerable interface.

https://learn.microsoft.com/en-us/dotnet/api/system.collections.ienumerator.movenext

Here is the question:

1. Why should we provide two version of Current method?
2. When the version ONE (object IEnumerator.Current) is used?
3. When the version TWO (public Person Current ) is used?
4. How to use PeopleEnum in the foreach statement. // updated

public class PeopleEnum : IEnumerator
{
    public Person[] _people;

    // Enumerators are positioned before the first element
    // until the first MoveNext() call.
    int position = -1;

    public PeopleEnum(Person[] list)
    {
        _people = list;
    }

    public bool MoveNext()
    {
        position++;
        return (position < _people.Length);
    }

    public void Reset()
    {
        position = -1;
    }

    // explicit interface implementation
    object IEnumerator.Current /// **version ONE**
    {
        get
        {
            return Current;
        }
    }

    public Person Current     /// **version TWO**
    {
        get
        {
            try
            {
                return _people[position];
            }
            catch (IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }
}

Answer 1

I suspect the reason is that this code example was derived from an example class implementing IEnumerator<T> – if the example class PeopleEnum implemented IEnumerator<T> this approach would be required: IEnumerator<T> inherits IEnumerator so you have to implement both interfaces when implementing IEnumerator<T>.

The implementation of the non-generic IEnumerator requires Current to return object – the strongly typed IEnumerator<T> on the other hand requires Current to return an instance of type T – using explicit and direct interface implementation is the only way to fulfill both requirements.