I want
to model a kind of FSM(Finite State Machine). I have a sequence of states (let's say, from StateA
to StateZ). This sequence is called a Chain and is implemented internally as a List. I will add states by the order I want them
to run.
My purpose is
to be able
to make a sequence of actions in my computer (for example, mouse clicks). (I know this has been done a zillion times).
So a state is defined as a:
boolean Precondition() <- Checks
to see if for this state, some condition is true. For example, if I want
to click in the Record button of a program, in this method I would check if the program's process is running or not. If it is, go
to the next state in the chain list, otherwise, go
to what was defined as the fail state (generally is the first state of them all).
IState GetNextState() <- Returns the next state
to evaluate. If Precondition() was sucessful, it should yield the next state in the chain otherwise it should yield the fail state.
Run() Simply checks the Precondition() and sets the internal data so GetNextState() works as expected.
So, a naive approach
to this would be something like this:
Chain chain = new Chain();
//chain.AddState(new State(Precondition, FailState, NextState) <- Method structure
chain.AddState(new State(new WinampIsOpenCondition(), null, new <problem here, I want
to referr
to a state that still wasn't defined!>);
The big problem is that I want
to make a reference
to a State that at this point still wasn't defined. I could circumvent the problem by using strings when refrering
to states and using an internal hashtable, but isn't there a clearer alternative?
I could just pass only the pre-condition and failure states in the constructor, having the chain just before execution put in each state the correct next state in a public property but that seems kind of awkward.
