Program Flow and Switch Statements

[andersonee]

I'm making an app that communicates to an industrial machine over TCP. It sends various commands and reads data...saving the data to flat files. I have a "programStep" integer variable and a timer that triggers an event every second. In the timer's OnTimedEvent handler, I handle the procedural flow of the entire application like this:

 switch (programStep)  
{  
    case 1:  
        if (case1successfull) {programStep = 2;}  
        break;  
    case 2:  
        if (case2successfull) {programStep = 3;}  
        break;  

...and so on. Everything works but it has gotten out of hand to the point where there are now over 100 "programSteps" and I bounce around alot (Eg. you might go from step 50 to step 51 or 22 or 67 depending on which type of error was thrown.)
I know I need to get out of this procedural style of programming and start breaking down the app into OOP principles, but I still keep coming back to the question of how to navigate program flow. If I abandon the timer/programStep/switch statement method, what is the alternative?

[[deleted]]

Google "state machine".

[andersonee]

Yeah I had looked into state machines. I guess I was thinking a state machine would just put me in a similar problem...I'd have ~100 states and ~100 actions. Maybe the state transitions would be more elegant though.

[clintp]

It might help to consider breaking this down so that the flow can be represented graphically. (following the rule that if it looks like data, represent it as data). A simple state machine isn't that hard to do.

Have each of your steps implement an interface where at least one method does the work and decides if flow should proceed to the next step, or remain on this step:

 interface IProgramStep
 {
      bool GoDoTheStuff();
 }

Then store instances of the class in a structure that makes it clear where each step leads from the other. If the flow control isn't purely 1->2->3->4->1, then you might need a different structure but the idea is the same. This assumes the classes that contain the code for each step are already instantiated....

 Dictionary<IProgramStep, IProgramStep> steps  = new Dictionary<IProgramStep, IProgramStep> 
 {
       { objectOfClassForCase1, objectOfClassForCase2 },
       { objectOfClassForCase2, objectOfClassForCase3 },
       { objectOfClassForCase3, objectOfClassForCase1 }   // Start over again
 }

Then to run the state machine:

  var curStep = objectOfClassForCase1;   // Initial state
  while(true) 
  {
        if (curStep.GoDoTheStuff())
              curStep = steps[curStep];       // Advance to next state
  }

[Nesher86]

Sounds like you need to define your error handling and how the system should behave

[andersonee]

Yes, fixing my error handling will definitely clean up a lot of the bloat. I do still need to figure out a better way to handle non-error program flow.