Programmazione di domande strutturali, controllo di molti stati e transizioni specifiche tra gli stati caso per caso

Incapsula ogni stato non banale in una classe di stato separata che sa come passare da uno stato all'altro. Quando si verifica una transizione, l'oggetto di stato cambia. Ad esempio, da "ConnectedState" a "DisconnectedState".

Modella il tuo problema come macchina di stato . Sono un grande fan del modello di stato per risolvere questi problemi.

Martin Wickman ha ragione nel suggerire uno stato macchina.

Sembra che tu possa trarre beneficio dall'annidamento di alcune delle tue informazioni di stato (es. stato di connessione) - nidificare significa che i tuoi stati sovraordinati avranno macchine di stato interne - nel qual caso potresti voler controllare < a href="http://en.wikipedia.org/wiki/UML_state_machine"> Macchine dello stato UML .

Le macchine a stati UML sono più complesse delle normali macchine a stati finiti e, secondo la mia esperienza, sono piuttosto ingombranti da implementare a mano. In alternativa, per ripulire ciò che hai ora e passare a un'implementazione più OOPish, puoi provare questo:

Dividi le cose in tre o quattro funzioni ortogonali:

• Una funzione di determinazione dello stato successivo - questo richiederebbe lo stato corrente della macchina e il suo input corrente e determinerebbe quale dovrebbe essere il successivo stato della macchina
• Una funzione di output di transizione - questo dovrebbe esaminare quale transizione di stato è stata presa, insieme con l'input, e reagire ad essa (paragonabile all'output di una macchina Mealy)
• Una funzione di output di stato - questo dovrebbe guardare lo stato corrente e l'output per esso (paragonabile all'output di una macchina Moore)
• Una funzione di transizione: chiama le altre tre funzioni e imposta lo stato della macchina

Esempio:

func getNextState(input, curr_state)
{
    if (curr_state == STATE_FOO)
    {
        if (input == fizz)
            return STATE_FIZZ
        else
            return STATE_BUZZ
    }
    else if (curr_state == STATE_BAR)
    {
        ...
    }
    else
    {
        return STATE_DONE
    }
}

func outputForTransition(input, prev_state, next_state)
{
    if (prev_state == STATE_FIZZ && next_state == STATE_BUZZ)
    {
        print "Fizz Buzz"
    }
    else if (prev_state == STATE_FOO && next_state == STATE_BAR)
    {
        ...
    }
}

func outputForState(curr_state)
{
    switch(curr_state)
    {
        case STATE_FOO:
            foo()
        case STATE_BAR:
            bar()
        case STATE_FIZZ:
            fizz()
        case STATE_BUZZ:
            buzz()
    }
}

func transitionStates(input)
{
    prev_state = curr_state
    curr_state = getNextState(input, curr_state)

    // you could use either or both output functions:
    outputForTransition(input, prev_state, curr_state)
    outputForState(curr_state)
}

Potrebbe sembrare ancora un po 'disordinato, ma credimi chiarisce un po' le cose.

(E ovviamente vorresti implementare quanto sopra dopo aver elaborato il tuo diagramma di stato.)