State Machine States

States

State represents stable configuration of State Machine.

In general, a State consists of:

• Name, uniquely identifying State within State Machine,
• Parent State, if State is a substate of Composite State or Orthogonal State,
• OnEntry, logic that is executed when a State is entered,
• OnExit, logic that is executed when a State is exited,
• OnInitialize, logic that is executed when a composite or orthogonal State initializes its child configuration,
• OnFinalize, logic that is executed when a composite or orthogonal State reaches its final configuration,
• Set of outgoing Transitions.

Types of States

There are four types of States:

1. Simple State that can have any number of outgoing Transitions,
2. Composite State that can have any number of outgoing Transitions and any number of States (called its substates) having their own Transitions,
3. Orthogonal State that is similar to Composite State, but its substates are grouped in any number of Regions that are considered orthogonal / parallel,
4. Final State that marks the end of State's flow and can't have any outgoing Transitions nor OnEntry / OnExit logic.

Definition

UML notation of two States connected by Transition:

stateDiagram-v2
SourceState --> TargetState

Loading

Equivalent Stateflows notation of States:

Lambda style

Definition fragment (inside the builder callback):

    /* fragment of State Machine definition */
    .AddState("SourceState", b => b
        .AddDefaultTransition("TargetState")
    )
    .AddState("TargetState")

Using lambda style means that States are represented by string names passed as parameters to Add*State methods.

Typed style

Definition fragment (inside the builder callback):

    /* fragment of State Machine definition */
    .AddState<SourceState>(b => b
        .AddDefaultTransition<TargetState>()
    )
    .AddState<TargetState>()

Using typed style means that States are represented by classes referenced in typed overloads of Add*State methods. Such classes must implement the appropriate interfaces; see State, Composite State, and Orthogonal State.

Logic

There are two places where logic can be injected into State (except Final State), both optional:

1. OnEntry:
   • is called whenever State is entered,
   • can cause side effects.
2. OnExit:
   • is called whenever State is exited,
   • can cause side effects.

The way of adding logic to States varies by declaration style; examples are available on the State page.

For Composite and Orthogonal States, there are two additional logic units:

1. OnInitialize:
   • is called whenever initial substate within Composite State / Orthogonal State's Region is entered,
   • can cause side effects.
2. OnFinalize:
   • is called whenever Final State within Composite State / Orthogonal State's Region is reached,
   • can cause side effects.

Deferring Events

Any State can declare event types to defer with AddDeferredEvent<TEvent>(). Matching deferrals are evaluated before normal transition processing; when a deferral guard passes, the event is retained and not offered to transitions in the current configuration. After later event processing, Stateflows reevaluates deferred events and processes a queued event normally once no active state defers it.

Deferrals declared on active ancestors and active states in orthogonal regions also apply. Optional deferral guards can make the decision conditional on the event payload or context. Completion, Finalize, and time events cannot be deferred. For details and examples, see In-State Event Deferrals.