Transito 1.0.0

Transito

A generic enum state machine library for .NET that provides attribute-based configuration and fluent builders for managing state transitions.

Features

• Attribute-based Configuration: Define state machines using simple attributes on your enums
• Fluent Builder Pattern: Programmatically configure state machines with a fluent API
• State Categorization: Organize states into categories (Initial, Active, Final, etc.)
• Extension Methods: Easy-to-use extension methods for common state operations
• Thread-safe: Built with concurrent collections for safe multi-threaded usage
• High Performance: Cached state machine instances for optimal performance

Installation

dotnet add package Transito

Quick Start

Attribute-based Configuration

using Transito.Attributes;

[StateMachine(InitialState = OrderStatus.Draft)]
public enum OrderStatus
{
    [StateCategory(StateCategory.Initial)]
    [AllowTransitionsTo(Submitted, Cancelled)]
    Draft,

    [StateCategory(StateCategory.Active)]
    [AllowTransitionsTo(Processing, Cancelled)]
    Submitted,

    [StateCategory(StateCategory.Active)]
    [AllowTransitionsTo(Shipped, Cancelled)]
    Processing,

    [StateCategory(StateCategory.Active)] 
    [AllowTransitionsTo(Delivered)]
    Shipped,

    [StateCategory(StateCategory.Final)]
    Delivered,

    [StateCategory(StateCategory.Final)]
    Cancelled
}

// Usage
var order = OrderStatus.Draft;

// Check valid transitions
bool canSubmit = order.CanTransitionTo(OrderStatus.Submitted); // true
bool canDeliver = order.CanTransitionTo(OrderStatus.Delivered); // false

// Get all valid transitions
var validTransitions = order.GetValidTransitions(); // [Submitted, Cancelled]

// Check state categories
bool isInitial = order.IsInitialState(); // true
bool isFinal = order.IsFinalState(); // false

Fluent Builder Pattern

using Transito.Builders;

var stateMachine = StateMachineBuilder<OrderStatus>
    .Configure()
    .Allow(OrderStatus.Draft).To(OrderStatus.Submitted, OrderStatus.Cancelled)
    .Allow(OrderStatus.Submitted).To(OrderStatus.Processing, OrderStatus.Cancelled)
    .Allow(OrderStatus.Processing).To(OrderStatus.Shipped, OrderStatus.Cancelled)
    .Allow(OrderStatus.Shipped).To(OrderStatus.Delivered)
    .Allow(OrderStatus.Delivered).ToNone()
    .Allow(OrderStatus.Cancelled).ToNone()
    .AddStateToCategory(OrderStatus.Draft, StateCategory.Initial)
    .AddStateToCategory(OrderStatus.Delivered, StateCategory.Final)
    .AddStateToCategory(OrderStatus.Cancelled, StateCategory.Final)
    .WithInitialState(OrderStatus.Draft)
    .Build();

// Use the state machine
bool canTransition = stateMachine.CanTransitionTo(OrderStatus.Draft, OrderStatus.Submitted);
var initialState = stateMachine.GetInitialState();

Available Attributes

• [StateMachine] - Marks an enum as a state machine
• [AllowTransitionsTo(...)] - Defines valid transitions from a state
• [StateCategory(...)] - Categorizes states (Initial, Active, Final, Intermediate, Error, Retry)

Extension Methods

• CanTransitionTo(newState) - Check if transition is valid
• GetValidTransitions() - Get all possible transitions
• IsInCategory(category) - Check if state belongs to category
• IsFinalState() - Check if state is final
• IsInitialState() - Check if state is initial
• IsActiveState() - Check if state is active

State Categories

• Initial - Starting states
• Active - States representing ongoing processes
• Final - Terminal states with no further transitions
• Intermediate - Temporary transition states
• Error - Error states
• Retry - States that allow retry operations

License

MIT License - see LICENSE file for details.