IEnumerable[<T>] represents a sequence of data, not a random-access list. Not all sequences can be reversed, or even replayed. Sequences based on network streams, database access, etc - or this beauty:

IEnumerable<int> GetData() {
    Random rand = new Random();
    while(true) { yield return rand.Next(); }
}

The best you can do is start again - not by calling Reset() (which is deprecated), but by getting a fresh enumerator instead.

Even without Random it is trivial to come up with simple sequences that cannot be reversed (without buffering and reversing the buffer). For what you want, consider looking at IList[<T>] instead - you can access data via the indexer in any order.

There are many types of data where it does not make sense to have a MovePrevious. For example, if you are receiving data from a network connection, providing a MovePrevious would require buffering the entire stream just in case you called that method. This would waste huge amounts of memory.

Having said that, it might be useful to have a different type which supported both MoveNext and MovePrevious (a doubly linked list could support this, for example).

Usage convenience isn t the only factor involved when designing an interface ... you have to take into account how versatile it ll be and how what constraints you are adding to it.

There are sequences that can t be replayed, and you d be adding a lot of unnecessary requirements to implementing it.

There are other interfaces besides it, like IList, IQueryable. Using the most appropriate for the scenario, also communicates the type of usage that it should have.

Implementing a MovePrevious would make it much heavier interface. While for some sources (array, Container classes) a MovePrevious would be trivial, for a lot of other sources it would require expensive buffering, or exclude those sources. Network streams and Database connections do not support Seek operations.

It s to do with the pattern regarding "yield". Effectively enumerators are the simplest possible collection, you simply start at the front and take until the very end. This means that they code to implement the enumeration is extremely simple.

Also you can have functional code using iterators which never "end" as such, for instance

yield value++;

You will simply receive incrementing numbers until you stop.