Is there a built-in way to convert IEnumerator to IEnumerable

Question

Is there a built-in way to convert IEnumerator<T> to IEnumerable<T>?

Answer 1

Nope, IEnumerator<> and IEnumerable<> are different beasts entirely.

Answer 2

As Jason Watts said -- no, not directly.

If you really want to, you could loop through the IEnumerator<T>, putting the items into a List<T>, and return that, but I'm guessing that's not what you're looking to do.

The basic reason you can't go that direction (IEnumerator<T> to a IEnumerable<T>) is that IEnumerable<T> represents a set that can be enumerated, but IEnumerator<T> is a specific enumeratation over a set of items -- you can't turn the specific instance back into the thing that created it.

Answer 3

You could use the following which will kinda work.

public FakeEnumerable<T> : public IEnumerable<T> {
  private IEnumerator<T> m_enumerator;
  public FakeEnumerable(IEnumerator<T> e) {
    m_enumerator = e;
  }
  public IEnumerator<T> GetEnumerator() { 
    return m_enumerator;
  }
  // Rest omitted 
}

This will get you into trouble though when people expect successive calls to GetEnumerator to return different enumerators vs. the same one. But if it's a one time only use in a very constrained scenario, this could unblock you.

I do suggest though you try and not do this because I think eventually it will come back to haunt you.

A safer option is along the lines Jonathan suggested. You can expend the enumerator and create a List<T> of the remaining items.

public static List<T> SaveRest<T>(this IEnumerator<T> enumerator) {
  var list = new List<T>();
  while ( e.MoveNext() ) {
    list.Add(e.Current);
  }
  return list;
}

Answer 4

The easiest way of converting I can think of is via the yield statement

public static IEnumerable<T> ToIEnumerable<T>(this IEnumerator<T> enumerator) {
  while ( enumerator.MoveNext() ) {
    yield return enumerator.Current;
  }
  yield break;
}

compared to the list version this has the advantage of not enumerating the entire list before returning an IEnumerable. using the yield statement you'd only iterate over the items you need, whereas using the list version, you'd first iterate over all items in the list and then all the items you need.

for a little more fun you could change it to

public static IEnumerable<K> Select<K,T>(this IEnumerator<T> enumerator, 
                                         Func<K,T> selector) {
      while ( e.MoveNext() ) {
        yield return selector(e.Current);
      }
      yield break;
    }

you'd then be able to use linq on your enumerator like:

IEnumerator<T> enumerator;
var someList = from item in enumerator
               select new classThatTakesTInConstructor(item);