Enumerators for Dependency Injection

A situation came up where I needed to select elements based on dependency injection. The elements were portions of a larger bitmap that were being used as tiles in a 2D graphics engine. Selection might be sequential, random, fixed, etc., but needed to be hidden from downstream processes. In particular, I needed to inject not the enumerators themselves, but enumerator factories.

At first I was going to use a custom interface. After some thought, however, I decided that the .NET IEnumerator<> interface fit the bill nicely. Technically an enumeration is some kind of ordered or unordered sequence from a collection. But a randomized sequence fits that bill, and it’s not too much of stretch to think of an infinitely looping sequence as an enumerator. (For example, think of the original collection as specifying the set of allowable items of an infinite sequence.)

So I came up the following helper functions:

static IEnumerator<TOutput> MakeEnumerator <TInput,TOutput,TState> (
  TInput inputIn,
  TState stateIn,
  Func<TInput,TState,TState>  funcMoveNext,
  Func<TInput,TState,bool>    funcMovedNextOk,
  Func<TInput,TState,TOutput> funcCurrent)
{
  while (true)
  {
    stateIn = funcMoveNext(inputIn,stateIn);
        
    if (!funcMovedNextOk (inputIn,stateIn))
      break;
        
    yield return funcCurrent(inputIn,stateIn);
  }
}


static Func<TInput,IEnumerator<TOutput>> MakeEnumeratorFunc <TInput,TOutput,TState> (
  TState stateIn,
  Func<TInput,TState,TState>  funcMoveNext,
  Func<TInput,TState,bool>    funcMovedNextOk,
  Func<TInput,TState,TOutput> funcCurrent)
{
  return 
    (i)=> (
      MakeEnumerator(
        i,
        stateIn,
        funcMoveNext,
        funcMovedNextOk,
        funcCurrent));
}

The first helper is a generic enumerator builder that takes three functions and a state which control the enumeration. The functions transition from state to state, determine whether a transition has exhausted the enumerator, and select an enumerated item. (I separated the move next functionality and inverted its typical order because it makes things a lot more convenient.)

The second helper uses this first helper to build an enumerator factory function.

Below shows how this could be used to build an enumerator factory for canonical list enumeration. (You wouldn’t want to use these functions for this in a typical scenario; the traditional way would suffice there. They are mainly useful in dependency injection situations.)

Func<List<int>,IEnumerator<int>> xMakeEnumeratorFunc =
  MakeEnumeratorFunc<List<int>,int,int>(
    -1,
    (i,s)=>(s+1),
    (i,s)=>(s<i.Count),
    (i,s)=>(i[s]));
        
List<int> xList = new List<int>() { 1, 3, 5, 7 };

IEnumerator<int> xEnumerator = xMakeEnumeratorFunc(xList);

// Inject xEnumerator here.

Fun, func, function!

(Tomorrow: I find a situation where a tradition boolean MoveNext is superior and post the overloaded functions.)

-Neil