C# - Why implement two version of Current when realizing IEnumerable Interface?

Question

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

https://docs.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

The IEnumerator.Current is an explicit interface implementation.

You can only use it if you cast the iterator to an IEnumerator (which is what the framework does with foreach). In other cases, the second version will be used.

You will see that it returns object and actually uses the other implementation which returns a Person.

The second implementation is not required per se by the interface, but is there as a convenience and in order to return the expected type instead of object.