Choice

Overview

Choice is a type of Pseudostate used in State Machines to model conditional branching. It allows the State Machine to evaluate multiple conditions and transition to different target states based on those conditions.

All Transitions coming out from Choice are Default Transitions - they are not explicitly triggered by an Event.

As Choice is a Pseudostate and not a State, State Machine can't stop its flow on it. Therefore, outgoing else Transition must be defined for each Choice to ensure that there will always be an alternative if all other conditions (Guards) are not met.

Definition

In UML, a Choice pseudostate is represented by a diamond shape with multiple outgoing transitions:

stateDiagram-v2
[*] --> InitialState
InitialState --> Choice : TriggerEvent
Choice --> State1 : [condition1]
Choice --> State2 : [condition2]
Choice --> State3 : [else]

Loading

Equivalent Stateflows notation of a Choice pseudostate:

Lambda style

    /* fragment of State Machine definition */
    .AddInitialState("InitialState", b => b
        .AddTransition<TriggerEvent>("Choice")
    )
    .AddChoice("Choice", b => b
        .AddTransition("State1", b => b
            .AddGuard(b => /* condition1 */)
        )
        .AddTransition("State2", b => b
            .AddGuard(b => /* condition2 */)
        )
        .AddElseTransition("State3")
    )
    .AddState("State1")
    .AddState("State2")
    .AddState("State3")

If there is just one Choice in State Machine, shortened notation with default name can be used:

Lambda style

    /* fragment of State Machine definition */
    .AddInitialState("InitialState", b => b
        .AddTransition<TriggerEvent>(Choice.Name)
    )
    .AddChoice(b => b // no name provided here, default name is used
        .AddTransition("State1", b => b
            .AddGuard(b => /* condition1 */)
        )
        .AddTransition("State2", b => b
            .AddGuard(b => /* condition2 */)
        )
        .AddElseTransition("State3")
    )
    .AddState("State1")
    .AddState("State2")
    .AddState("State3")

Using lambda style means that the Choice Pseudostate and its Transitions are defined using string names and lambda functions for conditions.

Typed style

    public class ChoiceCondition1 : IDefaultTransitionGuard
    {
        public Task<bool> GuardAsync()
        {
            return /* condition1 */;
        }
    }

    public class ChoiceCondition2 : IDefaultTransitionGuard
    {
        public Task<bool> GuardAsync()
        {
            return /* condition2 */;
        }
    }

    /* fragment of State Machine definition */
    .AddInitialState<InitialState>(b => b
        .AddTransition<TriggerEvent, Choice>()
    )
    .AddChoice(b => b
        .AddTransition<ChoiceCondition1, State1>()
        .AddTransition<ChoiceCondition2, State2>()
        .AddElseTransition<State3>()
    )
    .AddState<State1>()
    .AddState<State2>()
    .AddState<State3>()

Using typed style here means that Choice Pseudostate is represented by a class, in the example predefined Choice class is used.

Choice class can be used as a target for typed style Transitions if State Machine contains just one Choice. If there are more Choices, there is an important concern of State identity to be considered.