internal static void ExecuteEventDriven(ActivityExecutionContext context, EventDrivenActivity eventDriven)
{
StateMachineExecutionState executionState = GetExecutionState(context);
Debug.Assert(!executionState.HasEnqueuedActions);
ExecuteChild(context, eventDriven);
}
private static void ExecuteState(ActivityExecutionContext context)
{
StateMachineExecutionState executionState = GetExecutionState(context);
executionState.SchedulerBusy = false;
executionState.ProcessActions(context);
}
private static void ExecuteStateInitialization(ActivityExecutionContext context, StateInitializationActivity stateInitialization)
{
StateMachineExecutionState executionState = GetExecutionState(context);
Debug.Assert(!executionState.HasEnqueuedActions);
ExecuteChild(context, stateInitialization);
}
private static void CleanUp(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
StateActivity state = (StateActivity)context.Activity;
if (state.ExecutionStatus == ActivityExecutionStatus.Faulting)
{
return; // if we're faulting, then we're already in a bad state, so we don't try to unsubscribe
}
StateMachineExecutionState executionState = GetExecutionState(state);
StateMachineSubscriptionManager subscriptionManager = executionState.SubscriptionManager;
subscriptionManager.UnsubscribeState(context);
if (StateMachineHelpers.IsRootState(state))
{
subscriptionManager.DeleteSetStateEventQueue(context);
}
else if (StateMachineHelpers.IsLeafState(state))
{
subscriptionManager.UnsubscribeToSetStateEvent(context);
}
}
protected override void Enqueue(ActivityExecutionContext context)
{
StateActivity rootState = StateMachineHelpers.GetRootState((StateActivity)context.Activity);
StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
executionState.SubscriptionManager.Enqueue(context, this.SubscriptionId);
}
protected override void OnActivityChangeAdd(ActivityExecutionContext executionContext, Activity addedActivity)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (addedActivity == null)
{
throw new ArgumentNullException("addedActivity");
}
if (addedActivity.Enabled && (executionContext.Activity.ExecutionStatus == ActivityExecutionStatus.Executing))
{
EventDrivenActivity eventDriven = addedActivity as EventDrivenActivity;
if (eventDriven != null)
{
StateMachineSubscriptionManager.ChangeEventDrivenQueueState(executionContext, eventDriven, false);
StateMachineExecutionState state = StateMachineExecutionState.Get(StateMachineHelpers.GetRootState(executionContext.Activity as StateActivity));
if (StateMachineHelpers.GetCurrentState(executionContext) != null)
{
state.SubscriptionManager.ReevaluateSubscriptions(executionContext);
state.LockQueue();
state.ProcessActions(executionContext);
}
}
}
}
internal void RaiseProcessActionEvent(ActivityExecutionContext context)
{
StateMachineExecutionState executionState = GetExecutionState(context);
Debug.Assert(!executionState.SchedulerBusy);
executionState.SchedulerBusy = true;
base.Invoke <EventArgs>(this.HandleProcessActionEvent, new EventArgs());
}
private static StateMachineExecutionState GetExecutionState(StateActivity state)
{
if (state == null)
{
throw new ArgumentNullException("state");
}
return(StateMachineExecutionState.Get(StateMachineHelpers.GetRootState(state)));
}
internal override void ProcessEvent(ActivityExecutionContext context)
{
StateMachineExecutionState state = StateMachineExecutionState.Get(StateMachineHelpers.GetRootState((StateActivity)context.Activity));
ExternalEventAction action = new ExternalEventAction(this.StateName, this.EventDrivenName);
state.EnqueueAction(action);
state.ProcessActions(context);
}
internal static StateMachineExecutionState Get(StateActivity state)
{
Debug.Assert(StateMachineHelpers.IsRootState(state));
StateMachineExecutionState executionState = (StateMachineExecutionState)state.GetValue(StateActivity.StateMachineExecutionStateProperty);
Debug.Assert(executionState != null);
return(executionState);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
StateMachineExecutionState.Get(StateMachineHelpers.GetRootState(StateMachineHelpers.FindEnclosingState(executionContext.Activity))).NextStateName = this.TargetStateName;
return(ActivityExecutionStatus.Closed);
}
internal override void ProcessEvent(ActivityExecutionContext context)
{
StateActivity rootState = StateMachineHelpers.GetRootState((StateActivity)context.Activity);
StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
ExternalEventAction action = new ExternalEventAction(this.StateName, this.EventDrivenName);
Debug.Assert(!executionState.HasEnqueuedActions);
executionState.EnqueueAction(action);
executionState.ProcessActions(context);
}
internal virtual void Execute(ActivityExecutionContext context)
{
if (context == null)
throw new ArgumentNullException("context");
Debug.Assert(context.Activity.QualifiedName.Equals(this.StateName));
_state = (StateActivity)context.Activity;
_currentState = StateMachineHelpers.GetCurrentState(context);
StateActivity rootState = StateMachineHelpers.GetRootState(_state);
_executionState = StateMachineExecutionState.Get(rootState);
_subscriptionManager = _executionState.SubscriptionManager;
}
private static void HandleStateFinalizationCompleted(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
StateMachineExecutionState executionState = GetExecutionState(context);
Complete(context);
}
private static StateMachineExecutionState GetExecutionState(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
StateActivity state = (StateActivity)context.Activity;
StateMachineExecutionState executionState = GetExecutionState(state);
return(executionState);
}
internal virtual void Execute(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
this._state = (StateActivity) context.Activity;
this._currentState = StateMachineHelpers.GetCurrentState(context);
StateActivity rootState = StateMachineHelpers.GetRootState(this._state);
this._executionState = StateMachineExecutionState.Get(rootState);
this._subscriptionManager = this._executionState.SubscriptionManager;
}
internal virtual void Execute(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
this._state = (StateActivity)context.Activity;
this._currentState = StateMachineHelpers.GetCurrentState(context);
StateActivity rootState = StateMachineHelpers.GetRootState(this._state);
this._executionState = StateMachineExecutionState.Get(rootState);
this._subscriptionManager = this._executionState.SubscriptionManager;
}
private void HandleProcessActionEvent(object sender, EventArgs eventArgs)
{
ActivityExecutionContext context = sender as ActivityExecutionContext;
if (context == null)
{
throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender");
}
StateMachineExecutionState executionState = GetExecutionState(context);
executionState.SchedulerBusy = false;
executionState.ProcessActions(context);
}
private void ExecuteRootState(ActivityExecutionContext context)
{
StateActivity state = (StateActivity)context.Activity;
StateMachineExecutionState executionState = new StateMachineExecutionState(this.WorkflowInstanceId);
executionState.SchedulerBusy = false;
state.SetValue(StateActivity.StateMachineExecutionStateProperty, executionState);
executionState.SubscriptionManager.CreateSetStateEventQueue(context);
string initialStateName = StateMachineHelpers.GetInitialStateName(state);
executionState.CalculateStateTransition(this, initialStateName);
executionState.ProcessActions(context);
}
internal virtual void Execute(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
Debug.Assert(context.Activity.QualifiedName.Equals(this.StateName));
_state = (StateActivity)context.Activity;
_currentState = StateMachineHelpers.GetCurrentState(context);
StateActivity rootState = StateMachineHelpers.GetRootState(_state);
_executionState = StateMachineExecutionState.Get(rootState);
_subscriptionManager = _executionState.SubscriptionManager;
}
internal override void ProcessEvent(ActivityExecutionContext context)
{
SetStateEventArgs args = context.GetService <WorkflowQueuingService>().GetWorkflowQueue("SetStateQueue").Dequeue() as SetStateEventArgs;
StateActivity currentState = StateMachineHelpers.GetCurrentState(context);
if (currentState == null)
{
throw new InvalidOperationException(SR.GetStateMachineWorkflowMustHaveACurrentState());
}
StateMachineExecutionState state = StateMachineExecutionState.Get(StateMachineHelpers.GetRootState((StateActivity)context.Activity));
SetStateAction action = new SetStateAction(currentState.QualifiedName, args.TargetStateName);
state.EnqueueAction(action);
state.ProcessActions(context);
}
private static void EnteringLeafState(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
StateActivity state = (StateActivity)context.Activity;
Debug.Assert(StateMachineHelpers.IsLeafState(state));
StateMachineExecutionState executionState = GetExecutionState(state);
executionState.SubscriptionManager.SubscribeToSetStateEvent(context);
string completedStateName = StateMachineHelpers.GetCompletedStateName(state);
if (StateMachineHelpers.IsCompletedState(state))
{
// make sure that we track that we entered the completed state
EnteringStateAction enteringState = new EnteringStateAction(state.QualifiedName);
executionState.EnqueueAction(enteringState);
executionState.ProcessActions(context);
// this is the final state, so we start completing this tree
executionState.Completed = true;
LeavingState(context);
}
else
{
if (String.IsNullOrEmpty(executionState.NextStateName))
{
executionState.SubscriptionManager.ReevaluateSubscriptions(context);
EnteringStateAction enteringState = new EnteringStateAction(state.QualifiedName);
executionState.EnqueueAction(enteringState);
executionState.LockQueue();
}
else
{
// The StateInitialization requested a state transtion
EnteringStateAction enteringState = new EnteringStateAction(state.QualifiedName);
executionState.EnqueueAction(enteringState);
executionState.ProcessTransitionRequest(context);
}
executionState.ProcessActions(context);
}
}
private static void HandleSubStateCompleted(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
StateMachineExecutionState executionState = GetExecutionState(context);
if (executionState.Completed)
{
LeavingState(context);
}
else
{
executionState.ProcessActions(context);
}
}
private static void Complete(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
StateActivity activity = (StateActivity)context.Activity;
StateMachineExecutionState executionState = GetExecutionState(activity);
if (StateMachineHelpers.IsLeafState(activity))
{
executionState.PreviousStateName = activity.Name;
}
CleanUp(context);
executionState.SchedulerBusy = true;
context.CloseActivity();
}
internal static StateActivity GetCurrentState(ActivityExecutionContext context)
{
StateActivity state = context.Activity as StateActivity;
if (state == null)
{
state = FindEnclosingState(context.Activity);
}
StateActivity rootState = GetRootState(state);
string currentStateName = StateMachineExecutionState.Get(rootState).CurrentStateName;
if (currentStateName == null)
{
return(null);
}
return(FindDynamicStateByName(rootState, currentStateName));
}
protected override void OnActivityChangeAdd(ActivityExecutionContext executionContext, Activity addedActivity)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (addedActivity == null)
{
throw new ArgumentNullException("addedActivity");
}
if (!addedActivity.Enabled)
{
return;
}
if (executionContext.Activity.ExecutionStatus != ActivityExecutionStatus.Executing)
{
return; // activity is not executing
}
EventDrivenActivity eventDriven = addedActivity as EventDrivenActivity;
if (eventDriven == null)
{
return;
}
// Activity we added is an EventDrivenActivity
// First we disable the queue
StateMachineSubscriptionManager.ChangeEventDrivenQueueState(executionContext, eventDriven, false);
StateActivity rootState = StateMachineHelpers.GetRootState(executionContext.Activity as StateActivity);
StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
StateActivity currentState = StateMachineHelpers.GetCurrentState(executionContext);
if (currentState == null)
{
return; // Dynamic update happened before we entered the initial state
}
StateMachineSubscriptionManager subscriptionManager = executionState.SubscriptionManager;
subscriptionManager.ReevaluateSubscriptions(executionContext);
executionState.LockQueue();
executionState.ProcessActions(executionContext);
}
private static void ExecuteLeafState(ActivityExecutionContext context)
{
StateActivity activity = (StateActivity)context.Activity;
StateMachineExecutionState executionState = GetExecutionState(activity);
executionState.SchedulerBusy = false;
executionState.CurrentStateName = activity.QualifiedName;
StateInitializationActivity stateInitialization = GetStateInitialization(context);
if (stateInitialization != null)
{
ExecuteStateInitialization(context, stateInitialization);
}
else
{
EnteringLeafState(context);
}
}
private static void HandleStateInitializationCompleted(ActivityExecutionContext context, StateInitializationActivity stateInitialization)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (stateInitialization == null)
{
throw new ArgumentNullException("stateInitialization");
}
StateActivity activity = (StateActivity)context.Activity;
StateMachineExecutionState executionState = GetExecutionState(activity);
if (!string.IsNullOrEmpty(executionState.NextStateName) && executionState.NextStateName.Equals(activity.QualifiedName))
{
throw new InvalidOperationException(SR.GetInvalidSetStateInStateInitialization());
}
EnteringLeafState(context);
}
internal override void ProcessEvent(ActivityExecutionContext context)
{
WorkflowQueuingService workflowQueuingService = context.GetService <WorkflowQueuingService>();
WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName);
SetStateEventArgs eventArgs = workflowQueue.Dequeue() as SetStateEventArgs;
StateActivity currentState = StateMachineHelpers.GetCurrentState(context);
if (currentState == null)
{
throw new InvalidOperationException(SR.GetStateMachineWorkflowMustHaveACurrentState());
}
StateActivity rootState = StateMachineHelpers.GetRootState((StateActivity)context.Activity);
StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
SetStateAction action = new SetStateAction(currentState.QualifiedName, eventArgs.TargetStateName);
Debug.Assert(!executionState.HasEnqueuedActions);
executionState.EnqueueAction(action);
executionState.ProcessActions(context);
}
private static void HandleEventDrivenCompleted(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
StateActivity activity = (StateActivity)context.Activity;
StateMachineExecutionState executionState = GetExecutionState(context);
if (string.IsNullOrEmpty(executionState.NextStateName))
{
executionState.SubscriptionManager.ReevaluateSubscriptions(context);
executionState.LockQueue();
}
else
{
executionState.ProcessTransitionRequest(context);
}
executionState.ProcessActions(context);
}
private static void CleanupChildAtClosure(ActivityExecutionContext context, Activity childActivity)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (childActivity == null)
{
throw new ArgumentNullException("childActivity");
}
StateActivity state = (StateActivity)context.Activity;
StateMachineExecutionState executionState = GetExecutionState(state);
childActivity.Closed -= state.HandleChildActivityClosed;
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
ActivityExecutionContext childContext = contextManager.GetExecutionContext(childActivity);
contextManager.CompleteExecutionContext(childContext);
}
private static void ExecuteChild(ActivityExecutionContext context, Activity childActivity)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (childActivity == null)
{
throw new ArgumentNullException("childActivity");
}
StateActivity state = (StateActivity)context.Activity;
StateMachineExecutionState executionState = GetExecutionState(state);
Debug.Assert(!executionState.SchedulerBusy);
executionState.SchedulerBusy = true;
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
ActivityExecutionContext childContext = contextManager.CreateExecutionContext(childActivity);
childContext.Activity.Closed += state.HandleChildActivityClosed;
childContext.ExecuteActivity(childContext.Activity);
}
internal StateMachineSubscriptionManager(StateMachineExecutionState executionState, Guid instanceId)
{
_executionState = executionState;
_setStateSubscription = new SetStateSubscription(instanceId);
}
internal StateMachineSubscriptionManager(StateMachineExecutionState executionState, Guid instanceId)
{
this._executionState = executionState;
this._setStateSubscription = new System.Workflow.Activities.SetStateSubscription(instanceId);
}