A Simple State Machine in .NET - Adding Code-based Implementation

Introduction

On a previous post, I introduced my SimpleStateMachine project. Essentially, it provided an easy way to define a state machine from enumeration values. The version presented used attributes on these enumeration values to build up the state machine. Because this can sometimes be intrusive, and we may not want to "pollute" our enumerations, I decided to implement another way to define a state machine from an enumeration.

State Machines from Code

So, I came up with this interface:

public interface IStateMachine<T> where T : Enum
{
    T GetInitialState();
    IStateMachine<T> CanTransitionTo(T state, params IReadOnlyCollection<T> otherStates);
    IEnumerable<T> GetTransitions(T state);
    bool IsFinalState(T state);
    bool IsInitialState(T state);
}

It provides basically the same operations that were previously available:

  • Get the initial state of an enumeration (GetInitialState)
  • Check if an enumeration value is the initial (IsInitialState) or the final (IsFinalState) state
  • Get all possible transitions from a given state (GetTransitions)

But the way to achieve this is quite different: we now need to explicitly create the state machine and feed it with our desired transitions:

var created = TicketState.Created;

var stateMachine = created.Create();
stateMachine.CanTransitionTo(created, TicketState.Ready, TicketState.Closed);
stateMachine.CanTransitionTo(TicketState.Ready, TicketState.Blocked, TicketState.InReview, TicketState.Closed, TicketState.Ready);
stateMachine.CanTransitionTo(TicketState.InProgress, TicketState.InProgress, TicketState.Closed);
stateMachine.CanTransitionTo(TicketState.Blocked, TicketState.InProgress, TicketState.Closed);
stateMachine.CanTransitionTo(TicketState.InReview, TicketState.InProgress, TicketState.Closed);

Notice that the first method to be called, the one that creates the state machine, is Create, and it should be called on the initial state. Then we can add transitions to any state by using the CanTransitionTo method on the returned IStateMachine<T> instance.

When we are done, we can check in a very similar way as we did before:

var initialState = stateMachine.GetInitialState();
var isInitialState = created.IsInitialState();
var isFinalState = created.IsFinalState();
var canTransitionToClosed = created.CanTransitionTo(TicketState.Closed);
var canTransitionToBlocked = created.CanTransitionTo(TicketState.Blocked);
var transitions = created.GetTransitions();
So, essentially, we have a state machine in memory, that we can use and modify at any given time.

Conclusion

Goes without saying, I hope you find this useful, the Nuget package is already updated (targetting .NET 8), and I'll probably be adding some more features in the near future, so stay tuned!

GitHub: https://github.com/rjperes/SimpleStateMachine

Nuget: https://www.nuget.org/packages/SimpleStateMachine

Location: Coimbra, Portugal

Comments

Post a Comment

Popular posts from this blog

OpenTelemetry with ASP.NET Core

Image
Introduction I wrote a post not too long ago about the building blocks of telemetry , or distributed tracing , with ASP.NET Core. Now I'm going to talk about how we can see it working using an open source bundle, otel-lgtm . Mind you, this may not be 100% suitable for production, but for development purposes, it should be fine, all concepts apply, of course. I won't cover everything about OpenTelemetry here, but should hopefully give you some insights as to what's there and how you can make good use of it. First, lets see what some of the concepts are. If you're interested in learning more about metrics, I suggest having a look at my post on this topic . OpenTelemetry OpenTelemetry  (OTel) provides a single, open-source standard, and a set of technologies to capture and export metrics, traces, and logs from your cloud-native applications and infrastructure. OTel is both a standard and a reference implementation that builds on other standards, such as W3C Distributed Tr...
Read more

ASP.NET Core Middleware

Image
Introduction This post is another of those "back to basics", still, there was one thing or two that I feel were not properly discussed elsewhere, hence this post. The ASP.NET Core Pipeline and Middleware You may know that ASP.NET Core defines a pipeline. This is where the incoming requests are processed and the response submitted. Each component in the pipeline - a middleware - can do things with the message (the request), such as check if it is authenticated and have rights to access the requested resource, turn the request into an MVC-style controller and action invocation, log it, and what not. You can read more about it here . The ASP.NET Core pipeline, from Microsoft The order by which the middleware is added to the pipeline matters. For example, the authorisation middleware must come after the authentication one, static files must come before routing, and exception handling must come before everything. The middleware order, from Microsoft A middleware is just a piece of...
Read more

.NET Cancellation Tokens

Introduction Cancellation tokens in .NET were introduced as part of the  .NET 4 Cancellation Framework . Essentially, it is a standard, cooperative, way to request for the cancellation of the execution of an operation. By cooperative it means that the code that uses it must abide to some rules, as opposed to the cancellation just stopping (killing) the execution. One example of cancellation is, on a web app, when the client closes the connection while the server is performing some long operation. In cases such as this, we may want to abort the operation, as we are not sending the results anywhere (or not, as we shall see). Because of this, ASP.NET Core allows us to add a parameter of type  CancellationToken  to our asynchronous actions, it is automatically associated with the client and is therefore signalled when the client connection is closed. A  CancellationToken  is, essentially, behind the scenes, a ManualResetEvent . Throughout this article I will either ...
Read more