public override void MoveToState(TState state, StateTransitionOption option = StateTransitionOption.Default)
{
lock (syncRoot)
{
base.MoveToState(state, option);
}
}
public void MoveToState(TState state, StateTransitionOption option = StateTransitionOption.Default)
{
lock (syncRoot)
{
if (!IsEnabled)
{
return;
}
StateRepresentation <TState, TTrigger> rep;
if (configDictionary.TryGetValue(state, out rep))
{
if ((option & StateTransitionOption.CurrentStateExitTransition) ==
StateTransitionOption.CurrentStateExitTransition)
{
ExecuteAction(CurrentStateRepresentation.OnExitAction);
}
if ((option & StateTransitionOption.NewStateEntryTransition) ==
StateTransitionOption.NewStateEntryTransition)
{
ExecuteAction(rep.OnEntryAction);
}
CurrentStateRepresentation = rep;
}
else
{
throw new InvalidOperationException("Invalid state: " + state.ToString());
}
}
}
public async Task MoveToState(TState state, StateTransitionOption option = StateTransitionOption.Default)
{
if (!IsEnabled)
{
return;
}
var flag = true;
queueMonitor.Enter();
if (machine.Monitor.TryEnter())
{
if (queueCount == 0)
{
queueMonitor.Exit();
flag = false;
try
{
await machine.MoveToStateInternal(state, option);
}
finally
{
queueMonitor.Enter();
if (queueCount > 0)
{
queueMonitor.Exit();
var _ = StartQueueIfNecessaryAsync(true);
// Should not exit monitor here. Its handled by the process queue.
}
else
{
queueMonitor.Exit();
machine.Monitor.Exit();
}
}
}
}
if (flag)
{
var tcs = new TaskCompletionSource <bool>();
actionsQueue = actionsQueue.Enqueue(async() =>
{
try
{
await machine.MoveToStateInternal(state, option);
tcs.TrySetResult(true);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
});
queueCount++;
queueMonitor.Exit();
var _ = StartQueueIfNecessaryAsync();
await tcs.Task;
}
}
public async Task MoveToState(TState state, StateTransitionOption option = StateTransitionOption.Default)
{
if (Monitor.TryEnter())
{
try
{
if (!IsEnabled)
{
return;
}
await MoveToStateInternal(state, option).ConfigureAwait(false);
}
finally
{
Monitor.Exit();
}
}
else
{
if (IsEnabled)
{
throw new InvalidOperationException(
"State cannot be changed while in transition. Use the AsyncStateMachine instead, if these semantics are required.");
}
}
}
internal static void MoveToStateCore <TState, TTrigger>(TState state, StateTransitionOption option,
RawStateMachineBase <TState, TTrigger> machine, bool ignoreInvalidStates = false)
{
StateRepresentation <TState, TTrigger> targetRep;
if (machine.Representations.TryGetValue(state, out targetRep))
{
var currentRep = machine.CurrentStateRepresentation;
machine.RaiseTransitionStarted(targetRep.State);
var transition = new Transition <TState, TTrigger>(currentRep.State, state);
if ((option & StateTransitionOption.CurrentStateExitTransition) ==
StateTransitionOption.CurrentStateExitTransition)
{
currentRep.OnExitAction?.Invoke(transition);
}
if ((option & StateTransitionOption.NewStateEntryTransition) ==
StateTransitionOption.NewStateEntryTransition)
{
targetRep.OnEntryAction?.Invoke(transition);
}
var pastState = currentRep.State;
machine.CurrentStateRepresentation = targetRep;
machine.RaiseTransitionExecuted(pastState);
}
else
{
if (!ignoreInvalidStates)
{
machine.RaiseInvalidState(state);
}
}
}
public virtual void MoveToState(TState state, StateTransitionOption option = StateTransitionOption.Default)
{
if (!IsEnabled)
{
return;
}
ExecutionHelper.MoveToStateCore(state, option, this);
}
internal async Task MoveToStateInternal(TState state, StateTransitionOption option)
{
var currentRep = CurrentStateRepresentation;
AwaitableStateRepresentation <TState, TTrigger> rep;
if (configDictionary.TryGetValue(state, out rep))
{
if ((option & StateTransitionOption.CurrentStateExitTransition) ==
StateTransitionOption.CurrentStateExitTransition)
{
if (CheckFlag(currentRep.TransitionFlags, AwaitableStateTransitionFlag.ExitReturnsTask))
{
var action = CurrentStateRepresentation.OnExitAction as Func <Task>;
if (action != null)
{
await action();
}
}
else
{
var action = CurrentStateRepresentation.OnExitAction as Action;
if (action != null)
{
action();
}
}
}
if ((option & StateTransitionOption.NewStateEntryTransition) ==
StateTransitionOption.NewStateEntryTransition)
{
if (CheckFlag(rep.TransitionFlags, AwaitableStateTransitionFlag.EntryReturnsTask))
{
var action = rep.OnEntryAction as Func <Task>;
if (action != null)
{
await action();
}
}
else
{
var action = rep.OnEntryAction as Action;
if (action != null)
{
action();
}
}
}
CurrentStateRepresentation = rep;
}
else
{
throw new InvalidOperationException("Invalid state: " + state.ToString());
}
}
public override async Task MoveToStateAsync(TState state,
StateTransitionOption option = StateTransitionOption.Default)
{
var flag = true;
m_queueMonitor.Enter();
if (m_monitor.TryEnter())
{
if (m_queueCount == 0)
{
m_queueMonitor.Exit();
flag = false;
try { await base.MoveToStateAsync(state, option); }
finally
{
m_queueMonitor.Enter();
if (m_queueCount > 0)
{
m_queueMonitor.Exit();
var _ = StartQueueIfNecessaryAsync(true);
// Should not exit monitor here. Its handled by the process queue.
}
else
{
m_queueMonitor.Exit();
m_monitor.Exit();
}
}
}
}
if (flag)
{
var tcs = new TaskCompletionSource <bool>();
m_actionsQueue = m_actionsQueue.Enqueue(async() =>
{
try
{
await base.MoveToStateAsync(state, option);
tcs.TrySetResult(true);
}
catch (Exception ex) {
tcs.SetException(ex);
}
});
m_queueCount++;
m_queueMonitor.Exit();
var _ = StartQueueIfNecessaryAsync();
await tcs.Task;
}
}
public override void MoveToState(TState state, StateTransitionOption option = StateTransitionOption.Default)
{
if (m_monitor.TryEnter())
{
try { base.MoveToState(state, option); }
finally { m_monitor.Exit(); }
}
else
{
if (IsEnabled)
{
ExecutionHelper.ThrowInTransition();
}
}
}
public override async Task MoveToStateAsync(TState state,
StateTransitionOption option = StateTransitionOption.Default)
{
if (m_monitor.TryEnter())
{
try { await base.MoveToStateAsync(state, option).ConfigureAwait(false); }
finally { m_monitor.Exit(); }
}
else
{
if (IsEnabled)
{
AwaitableExecutionHelper.ThrowInTransition();
}
}
}
public void MoveToState(TState state, StateTransitionOption option = StateTransitionOption.Default)
{
if (monitor.TryEnter())
{
try
{
if (!IsEnabled)
{
return;
}
StateRepresentation <TState, TTrigger> rep;
if (configDictionary.TryGetValue(state, out rep))
{
if ((option & StateTransitionOption.CurrentStateExitTransition) ==
StateTransitionOption.CurrentStateExitTransition)
{
ExecuteAction(CurrentStateRepresentation.OnExitAction);
}
if ((option & StateTransitionOption.NewStateEntryTransition) ==
StateTransitionOption.NewStateEntryTransition)
{
ExecuteAction(rep.OnEntryAction);
}
CurrentStateRepresentation = rep;
}
else
{
throw new InvalidOperationException("Invalid state: " + state.ToString());
}
}
finally
{
monitor.Exit();
}
}
else
{
if (IsEnabled)
{
throw new InvalidOperationException("State cannot be changed while in transition. Use AsyncStateMachine or a BlockingStateMachine for these semantics.");
}
}
}
internal static async Task MoveToStateCoreAsync <TState, TTrigger>(TState state, StateTransitionOption option,
RawAwaitableStateMachineBase <TState, TTrigger> machine, bool raiseInvalidStates = true)
{
AwaitableStateRepresentation <TState, TTrigger> targetRep;
if (machine.Representations.TryGetValue(state, out targetRep))
{
var currentRep = machine.CurrentStateRepresentation;
machine.RaiseTransitionStarted(targetRep.State);
var transition = new Transition <TState, TTrigger>(currentRep.State, state);
if ((option & StateTransitionOption.CurrentStateExitTransition) ==
StateTransitionOption.CurrentStateExitTransition)
{
if (
AwaitableStateConfigurationHelper.CheckFlag(
currentRep.AwaitableTransitionFlags, AwaitableTransitionFlag.ExitReturnsTask))
{
var action = currentRep.OnExitAction as Func <Transition <TState, TTrigger>, Task>;
if (action != null)
{
await action(transition);
}
}
else
{
var action = currentRep.OnExitAction as Action <Transition <TState, TTrigger> >;
action?.Invoke(transition);
}
}
if ((option & StateTransitionOption.NewStateEntryTransition) ==
StateTransitionOption.NewStateEntryTransition)
{
if (AwaitableStateConfigurationHelper.CheckFlag(
targetRep.AwaitableTransitionFlags, AwaitableTransitionFlag.EntryReturnsTask))
{
var action = targetRep.OnEntryAction as Func <Transition <TState, TTrigger>, Task>;
if (action != null)
{
await action(transition);
}
}
else
{
var action = targetRep.OnEntryAction as Action <Transition <TState, TTrigger> >;
action?.Invoke(transition);
}
}
var pastState = currentRep.State;
machine.CurrentStateRepresentation = targetRep;
machine.RaiseTransitionExecuted(pastState);
}
else
{
if (raiseInvalidStates)
{
machine.RaiseInvalidState(state);
}
}
}
public virtual Task MoveToStateAsync(TState state, StateTransitionOption option = StateTransitionOption.Default)
{
return(!IsEnabled
? TaskHelpers.CompletedTask
: AwaitableExecutionHelper.MoveToStateCoreAsync(state, option, this));
}
public Task MoveToState(TState state, StateTransitionOption option = StateTransitionOption.Default)
{
return(!IsEnabled
? Task.FromResult(false)
: RunOnScheduler(() => machine.MoveToStateInternal(state, option)));
}
public abstract Task MoveToState(T state, StateTransitionOption option = StateTransitionOption.Default);
public override Task MoveToStateAsync(TState state, StateTransitionOption option = StateTransitionOption.Default)
{
return(RunOnScheduler(() => base.MoveToStateAsync(state, option)));
}
