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))); }