c# - machine - Configuración básica de la máquina de estados usando Stateless

stateless framework

Question

Tengo algunas necesidades estatales bastante simples (por ahora). Creo que me gustaría modelar esto usando la API de Stateless . (Pero realmente no sé mucho acerca de las máquinas de estado, por lo que podría estar equivocado).

Pero estoy atrapado en la terminología (específicamente, estado y disparador )

Aquí hay un ejemplo: Tengo una clase de orden. Se configura con varios estados. Ellos son: Nuevo, Llenado, Envío, Completado, Cancelado.

Algunas reglas de estado simples que me gustaría es que estas transiciones de estado estén permitidas:

• Nuevo (es el predeterminado)
• Nuevo -> Relleno
• Nuevo -> Cancelado
• Rellenado -> Envío
• Rellenado -> Cancelado
• Rellenado -> Envío
• Envío -> Completo

Entonces, ¿dónde me estoy tropezando aquí es cuál es mi "Disparador"?

En caso de que se necesite un ejemplo más específico, digamos que quiero un método como este:

public bool UpdateOrderStatus(int OrderId, OrderStatusEnum NewOrderStatus)

que devolverá verdadero si el estado se actualizó correctamente. ¿Cómo se puede configurar y usar Stateless para que esto suceda?

Answer 1

La máquina está en un solo estado a la vez; el estado en el que se encuentra en un momento dado se denomina estado actual. Puede cambiar de un estado a otro cuando se inicia por un evento o condición desencadenante , esto se llama una transición. de la máquina de estados finitos en Wiki

Creo que el desencadenante es este evento desencadenante .

Actualizar:

Por supuesto, el nombre del activador a veces puede ser igual a algunos de los nombres de estado.

New (initial state)
New -> Filled (trigger "Filled")
New -> Cancelled (trigger "Cancelled")
Filled -> Shipping (trigger "ToBeShipped")
Filled -> Cancelled (trigger "Cancelled")
Shipping -> Complete (trigger "Completed").

Actualizar:

Sin estado es un marco muy bonito! He intentado implementar la funcionalidad.

Estados:

public enum State
{
    New,
    Filled,
    Shipping,
    Cancelled,
    Completed
}

Gatillos

public enum Trigger
{
    Filled,
    Cancelled,
    ToBeShipped,
    Completed
}

Clase de orden

public class Order
{
    private readonly StateMachine<State, Trigger> _stateMachine;

    public Order()
    {
        _stateMachine = CreateStateMachine();
    }

    public bool TryUpdateOrderStatus(Trigger trigger)
    {
        if (!_stateMachine.CanFire(trigger))
            return false;

        _stateMachine.Fire(trigger);
        return true;
    }

    public State Status
    {
        get
        {
            return _stateMachine.State;
        }
    }

    private StateMachine<State, Trigger> CreateStateMachine()
    {
        StateMachine<State, Trigger> stateMachine = new StateMachine<State, Trigger>(State.New);
        stateMachine.Configure(State.New)
            .Permit(Trigger.Filled, State.Filled)
            .Permit(Trigger.Cancelled, State.Cancelled);

        stateMachine.Configure(State.Filled)
            .Permit(Trigger.ToBeShipped, State.Shipping)
            .Permit(Trigger.Cancelled, State.Cancelled);

        stateMachine.Configure(State.Shipping)
            .Permit(Trigger.Completed, State.Completed);

        stateMachine.OnUnhandledTrigger((state, trigger) =>
            {
                Console.WriteLine("Unhandled: ''{0}'' state, ''{1}'' trigger!");
            });
        return stateMachine;
    }
}

Probador para la clase de orden:

Order order = new Order();
bool result = order.TryUpdateOrderStatus(Trigger.Completed);
Console.WriteLine("Attemp to complete order: {0}", result);
Console.WriteLine("Order status: {0}", order.Status);

result = order.TryUpdateOrderStatus(Trigger.ToBeShipped);
Console.WriteLine("Attemp to ship order: {0}", result);
Console.WriteLine("Order status: {0}", order.Status);

result = order.TryUpdateOrderStatus(Trigger.Cancelled);
Console.WriteLine("Attemp to cancel order: {0}", result);
Console.WriteLine("Order status: {0}", order.Status);