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 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);
}
}
}
}
protected override void Initialize(IServiceProvider provider)
{
base.Initialize(provider);
ActivityExecutionContext context = (ActivityExecutionContext)provider;
StateActivity rootState = StateMachineHelpers.GetRootState(this);
if (!StateMachineHelpers.IsStateMachine(rootState))
{
throw new InvalidOperationException(SR.GetError_StateActivityMustBeContainedInAStateMachine());
}
string initialStateName = StateMachineHelpers.GetInitialStateName(this);
if (String.IsNullOrEmpty(initialStateName))
{
throw new InvalidOperationException(SR.GetError_CannotExecuteStateMachineWithoutInitialState());
}
//
if (this.QualifiedName != initialStateName)
{
StateMachineSubscriptionManager.DisableStateWorkflowQueues(context, this);
}
}
internal override void Execute(ActivityExecutionContext context)
{
base.Execute(context);
StateActivity rootState = StateMachineHelpers.GetRootState(base.State);
Queue <StateActivity> queue = new Queue <StateActivity>();
queue.Enqueue(rootState);
while (queue.Count > 0)
{
foreach (Activity activity3 in queue.Dequeue().EnabledActivities)
{
EventDrivenActivity eventDriven = activity3 as EventDrivenActivity;
if (eventDriven != null)
{
IComparable queueName = StateMachineHelpers.GetEventActivity(eventDriven).QueueName;
if (queueName != null)
{
WorkflowQueue workflowQueue = StateMachineSubscriptionManager.GetWorkflowQueue(context, queueName);
if (workflowQueue != null)
{
workflowQueue.Enabled = base.SubscriptionManager.Subscriptions.ContainsKey(queueName);
}
}
}
else
{
StateActivity item = activity3 as StateActivity;
if (item != null)
{
queue.Enqueue(item);
}
}
}
}
}
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 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;
}
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;
}
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 CleanUp(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
StateActivity state = (StateActivity)context.Activity;
if (state.ExecutionStatus != ActivityExecutionStatus.Faulting)
{
StateMachineSubscriptionManager subscriptionManager = GetExecutionState(state).SubscriptionManager;
subscriptionManager.UnsubscribeState(context);
if (StateMachineHelpers.IsRootState(state))
{
subscriptionManager.DeleteSetStateEventQueue(context);
}
else if (StateMachineHelpers.IsLeafState(state))
{
subscriptionManager.UnsubscribeToSetStateEvent(context);
}
}
}
internal override void Execute(ActivityExecutionContext context)
{
base.Execute(context);
StateActivity state = this.State;
StateActivity rootState = StateMachineHelpers.GetRootState(state);
Queue <StateActivity> states = new Queue <StateActivity>();
states.Enqueue(rootState);
while (states.Count > 0)
{
state = states.Dequeue();
foreach (Activity activity in state.EnabledActivities)
{
EventDrivenActivity eventDriven = activity as EventDrivenActivity;
if (eventDriven != null)
{
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
IComparable queueName = eventActivity.QueueName;
if (queueName != null)
{
WorkflowQueue queue = StateMachineSubscriptionManager.GetWorkflowQueue(context, queueName);
if (queue != null)
{
queue.Enabled = this.SubscriptionManager.Subscriptions.ContainsKey(queueName);
}
}
}
else
{
StateActivity childState = activity as StateActivity;
if (childState != null)
{
states.Enqueue(childState);
}
}
}
}
}
internal StateMachineExecutionState(Guid instanceId)
{
_subscriptionManager = new StateMachineSubscriptionManager(this, instanceId);
}
internal StateMachineExecutionState(Guid instanceId)
{
_subscriptionManager = new StateMachineSubscriptionManager(this, instanceId);
}
