A simple implementation gives the Enumerator object a private reference to a CurrentState object; each CurrentState object is an instance of a private class, nested within the Enumerator class, that has a reference to the Enumerator instance so that it can change the CurrentState.
The only problem, here, is that each different enumeration needs to build the state machine infrastructure all over again: reusability demands looser coupling.
Similarly, you could implement the current state handler as a virtual method, but this requires that all state classes descend from a common, abstract ancestor. While this is probably fine in at least 99.9% of all cases, using interfaces presents a bit more flexibility.
Thus, StateMachines.cs includes an abstract Enumerator class which expects state handler classes to support IStateHandler:
public interface IStateHandler
{
bool MoveNext(IStateMachine StateMachine) ;
}
The abstract Enumerator class supports IEnumerator via a generic state machine:
private IStateHandler CurrentState;
private object CurrentValue ;
protected abstract IStateHandler StartState() ;
public void Reset()
{
CurrentState = /*abstract*/ StartState();
CurrentValue = null;
}
public object Current
{
get { return CurrentValue ; }
}
public bool MoveNext()
{
return CurrentState.MoveNext(this);
}
Reset() sets an initial state handler, and MoveNext() iterates the state machine by calling the current state's handler. Now, sometimes you have to cycle the state machine through a few iterations before you get to an output state. For example, a given directory may have subdirectories but no files, or you may have just processed the last subdirectory of a last subdirectory, and so on. In an enum and switch implementation, this might be done with code like this:
bool Deliver = false;
do
switch (CurrentState)
{
}
while (! Deliver);
This loops until a state handler sets Deliver to true.
In my loosely-coupled, object-oriented implementation, the abstract Enumerator class supports the IStateMachine interface, which provides state classes with a couple of utilities: bool Yield() sets the internal CurrentValue (and, optionally, the CurrentState) and returns true; bool Recurse() sets the CurrentState, and recursively returns whatever the new state's IMoveNext implementation returns:
bool IStateMachine.Yield(object NewValue)
{
CurrentValue = NewValue;
return true;
}
bool IStateMachine.Yield(object NewValue, IStateHandler NextState)
{
CurrentValue = NewValue;
CurrentState = NextState;
return true;
}
bool IStateMachine.Recurse(IStateHandler NextState)
{
if (NextState == null)
return false; // no next state, no next item
CurrentState = NextState;
return NextState.MoveNext(this); // recurse
}
That is, return Yield() sets a new CurrentValue and suspends the state machine; return Recurse() passes control to a new state handler (which may itself either Yield() or Recurse()) and passes the result back out to the "outer process."
The actual state classes are nested two deep in the AllFiles class, which implements IEnumerable by returning a new instance of the nested private class DirectoryEnumerator: Enumerator.DirectoryEnumerator overrides StartState() and contains the actual state handler classes, ShowDirectory, ShowFiles, and ShowSubdirectories.
The start state is ShowDirectory, with a null next state, and the DirectoryInfo passed to the AllFiles constructor:
protected override IStateHandler StartState()
{
return new ShowDirectory(null, RootDirectory);
}
Thus, calling Enumerator.MoveNext() after a Reset() calls the ShowDirectory state handler:
public bool MoveNext(IStateMachine StateMachine)
{
IStateHandler subdirectories =
new ShowSubdirectories(NextState, Directory.GetDirectories());
IStateHandler files =
new ShowFiles(subdirectories, Directory.GetFiles());
// set Current to this directory; next time, scan files
return StateMachine.Yield(Directory, files);
}
This first creates a ShowSubdirectories state that "returns" to the ShowDirectory state's NextState. Then, it creates a ShowFiles state that "forwards" to the ShowSubdirectories state. Finally, it sets the CurrentValue to Directory and returns true.
The ShowFiles constructor calls GetEnumerator() on its second, IEnumerable parameter, and ShowFiles.MoveNext() either steps this array enumerator or passes control to the next, ShowSubdirectories state:
public bool MoveNext(IStateMachine StateMachine)
{
if (ArrayEnumerator.MoveNext())
return StateMachine.Yield((FileInfo) ArrayEnumerator.Current);
else
return StateMachine.Recurse(NextState);
}
The ShowSubdirectories constructor similarly calls GetEnumerator() on its second, IEnumerable parameter, and ShowSubdirectories.MoveNext() either steps this array enumerator and recursively sets the NewDirectory state to iterate the subdirectory, or "returns" to the parent directory state, which may be null:
public bool MoveNext(IStateMachine StateMachine)
{
if (ArrayEnumerator.MoveNext())
// at least one more subdirectory - recurse
return StateMachine.Recurse(
new ShowDirectory(this,
(DirectoryInfo) ArrayEnumerator.Current));
else
// no (more) subdirectories - pop
return StateMachine.Recurse(NextState);
}
As you can see, ShowSubdirectories is a strictly internal state that never yields control to the "outer process." It either invokes the ShowDirectory state with itself as the parent state, or it returns control to its own parent.
