Jason State

Jason State is a simple state machine implementation. It's configured by a JSON file.

Supported Platforms

• .NET Standard 2.1
• .NET Standard 2.0

Features

• Dependency injection friendly (can also be used standalone, see below)

Table of Contents

1. Why Jason State?
2. Installation
3. Usage
   • Json File
   • State Implementation
   • State Context
   • Microsoft.Extensions.DependencyInjection Initialization
4. License

Why Jason State?

• No need to worry about implementing State Pattern. With Jason State, it is already implemented!
• Because you use state pattern, your code is cleaner.
• Let the business need change! It'll give you the flexibility to change the flow just by the JSON file you provide. No need for deployment!
• Supports sync and async operations!

Installation

	Package
JasonState
JasonState.Extension

Following commands can be used to install JasonState and JasonState.Extension, run the following command in the Package Manager Console

dotnet add package JasonState
dotnet add package JasonState.Extension

Or use dotnet cli

dotnet add package JasonState
dotnet add package JasonState.Extension

Usage

Json

First you need to provide a valid JSON file. This JSON file must contain a States array. This array should have objects.

• Namespace: namespace of your state
• Name: Just the name of your state file
• NextState: array contains objects
  • Condition: The condition for the states execution.
  • State: State is next state's name. No need to provide namespace
• ErrorState: Name of your state's error state. This state will be executed only if the current state has an exception that you don't handle. Error state can be different for each state.

An example of a valid JSON file can be found throug

{
  "States": [
    {
      "Namespace": "TestClient.Impls.States",
      "Name": "InitialState",
      "NextState": [
        {
          "Condition": "!string.IsNullOrEmpty(FromEmail) && FromEmail.Equals(\"aksel@test.com\")",
          "State": "ValidatePaymentState"
        },
        {
          "Condition": "!string.IsNullOrEmpty(FromEmail) && FromEmail.Equals(\"test@test.com\")",
          "State": "FinalState"
        }
      ],
      "ErrorState": "ErrorState"
    },
    {
      "Namespace": "TestClient.Impls.States",
      "Name": "ErrorState",
      "NextState": [
        {
          "Condition": "true",
          "State": "FinalState"
        }
      ],
      "ErrorState": null
    },
    {
      "Namespace": "TestClient.Impls.States",
      "Name": "FinalState",
      "NextState": null,
      "ErrorState": null
    }
  ]
}

State Implementation

States must inherit from and implement Execute, or ExecuteAsync, method with your state context. You can use any dependency injection framework for construction injections. It will not break anything.

public class InitialState : BaseState<TestStateContext>
{
    public override void Execute(TestStateContext context)
    {
      // do the magic
    }
}

State Context

Jason State allows you to add any kind of object to the context. Everything you need during the state execution should be in the context.

public class TestStateContext
{
    public long CreditCardNumber { get; set; }

    public string CardHolderName { get; set; }

    public decimal Amount { get; set; }
}

public class InitialState : BaseState<TestStateContext>
{
    public override void Execute(TestStateContext context)
    {
        context.CreditCardNumber = "4545454545454545";
    }
}

Microsoft.Extensions.DependencyInjection Initialization

By referencing JasonState.Extension, register necessary dependencies to ServiceCollection as follows

serviceCollection.AddJasonState<TestStateContext>();

or

serviceCollection.AddAsyncJasonState<TestStateContext>();

Samples

TestClient can be found
AsyncTestClient can be found

License

Licensed under MIT, see LICENSE for the full text.