public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
StateFinalizationActivity compositeActivity = obj as StateFinalizationActivity;
if (compositeActivity == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(StateFinalizationActivity).FullName }), "obj");
}
StateActivity parent = compositeActivity.Parent as StateActivity;
if (parent == null)
{
errors.Add(new ValidationError(SR.GetError_StateFinalizationParentNotState(), 0x606));
return(errors);
}
foreach (Activity activity3 in parent.EnabledActivities)
{
StateFinalizationActivity activity4 = activity3 as StateFinalizationActivity;
if ((activity4 != null) && (activity4 != compositeActivity))
{
errors.Add(new ValidationError(SR.GetError_MultipleStateFinalizationActivities(), 0x61a));
break;
}
}
if (StateMachineHelpers.ContainsEventActivity(compositeActivity))
{
errors.Add(new ValidationError(SR.GetError_EventActivityNotValidInStateFinalization(), 0x603));
}
return(errors);
}
protected override void Enqueue(ActivityExecutionContext context)
{
StateActivity rootState = StateMachineHelpers.GetRootState((StateActivity)context.Activity);
StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
executionState.SubscriptionManager.Enqueue(context, this.SubscriptionId);
}
private static ReadOnlyCollection <StateActivity> GetLeafStates(StateActivity parentState)
{
if (parentState == null)
{
throw new ArgumentNullException("parentState");
}
List <StateActivity> leafStates = new List <StateActivity>();
Queue <StateActivity> states = new Queue <StateActivity>();
states.Enqueue(parentState);
while (states.Count > 0)
{
StateActivity parent = states.Dequeue();
foreach (Activity childActivity in parent.EnabledActivities)
{
StateActivity childState = childActivity as StateActivity;
if (childState != null)
{
if (StateMachineHelpers.IsLeafState(childState))
{
leafStates.Add(childState);
}
else
{
states.Enqueue(childState);
}
}
}
}
return(leafStates.AsReadOnly());
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = new ValidationErrorCollection(base.Validate(manager, obj));
SetStateActivity setState = obj as SetStateActivity;
if (setState == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(StateActivity).FullName }), "obj");
}
if (SetStateContainment.Validate(setState, validationErrors))
{
if (string.IsNullOrEmpty(setState.TargetStateName))
{
validationErrors.Add(new ValidationError(SR.GetString("Error_PropertyNotSet", new object[] { "TargetStateName" }), 0x116, false, "TargetStateName"));
return(validationErrors);
}
StateActivity state = StateMachineHelpers.FindStateByName(StateMachineHelpers.GetRootState(StateMachineHelpers.FindEnclosingState(setState)), setState.TargetStateName);
if (state == null)
{
validationErrors.Add(new ValidationError(SR.GetError_SetStateMustPointToAState(), 0x5f3, false, "TargetStateName"));
return(validationErrors);
}
if (!StateMachineHelpers.IsLeafState(state))
{
validationErrors.Add(new ValidationError(SR.GetError_SetStateMustPointToALeafNodeState(), 0x5f4, false, "TargetStateName"));
}
}
return(validationErrors);
}
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);
}
}
}
}
}
private static ReadOnlyCollection <StateActivity> GetLeafStates(StateActivity parentState)
{
if (parentState == null)
{
throw new ArgumentNullException("parentState");
}
List <StateActivity> list = new List <StateActivity>();
Queue <StateActivity> queue = new Queue <StateActivity>();
queue.Enqueue(parentState);
while (queue.Count > 0)
{
foreach (Activity activity2 in queue.Dequeue().EnabledActivities)
{
StateActivity state = activity2 as StateActivity;
if (state != null)
{
if (StateMachineHelpers.IsLeafState(state))
{
list.Add(state);
}
else
{
queue.Enqueue(state);
}
}
}
}
return(list.AsReadOnly());
}
private static void ValidateInitialState(StateActivity state, ValidationErrorCollection validationErrors)
{
string initialStateName = StateMachineHelpers.GetInitialStateName(state);
if (string.IsNullOrEmpty(initialStateName))
{
if (state.Activities.Count > 0)
{
validationErrors.Add(new ValidationError(SR.GetString("Error_PropertyNotSet", new object[] { "InitialStateName" }), 0x116, false, "InitialStateName"));
}
}
else
{
StateActivity activity = StateMachineHelpers.FindStateByName(state, initialStateName);
if (activity == null)
{
validationErrors.Add(new ValidationError(SR.GetError_InitialStateMustPointToAState(), 0x5f5, false, "InitialStateName"));
}
else
{
if (!StateMachineHelpers.IsLeafState(activity))
{
validationErrors.Add(new ValidationError(SR.GetError_InitialStateMustPointToALeafNodeState(), 0x5f7, false, "InitialStateName"));
}
string completedStateName = StateMachineHelpers.GetCompletedStateName(state);
if (initialStateName == completedStateName)
{
validationErrors.Add(new ValidationError(SR.GetError_InitialStateMustBeDifferentThanCompletedState(), 0x62c, false, "InitialStateName"));
}
}
}
}
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 void UnsubscribeEventDriven(ActivityExecutionContext context, EventDrivenActivity eventDriven)
{
Debug.Assert(IsEventDrivenSubscribed(eventDriven));
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
UnsubscribeEventActivity(context, eventActivity);
}
private bool IsEventDrivenSubscribed(EventDrivenActivity eventDriven)
{
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
EventActivitySubscription subscription = GetSubscription(eventActivity);
return(subscription != null);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (StateMachineHelpers.IsRootState(this))
{
ExecuteRootState(executionContext);
}
else
{
if (StateMachineHelpers.IsLeafState(this))
{
ExecuteLeafState(executionContext);
}
else
{
ExecuteState(executionContext);
}
}
return(this.ExecutionStatus);
}
internal static void LeavingState(ActivityExecutionContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
StateActivity state = (StateActivity)context.Activity;
if (StateMachineHelpers.IsLeafState(state))
{
StateFinalizationActivity stateFinalization = GetStateFinalization(context);
if (stateFinalization == null)
{
Complete(context);
}
else
{
ExecuteStateFinalization(context, stateFinalization);
}
}
else
{
Complete(context);
}
}
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);
}
}
}
}
internal void SubscribeEventDriven(ActivityExecutionContext context, EventDrivenActivity eventDriven)
{
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
Activity activity1 = (Activity)eventActivity;
GetQueueName(eventActivity);
this.SubscribeEventActivity(context, eventActivity);
}
private static void InvalidChildActivity(StateActivity state)
{
if (StateMachineHelpers.IsLeafState(state))
{
throw new InvalidOperationException(SR.GetError_InvalidLeafStateChild());
}
throw new InvalidOperationException(SR.GetError_InvalidCompositeStateChild());
}
internal static StateMachineExecutionState Get(StateActivity state)
{
Debug.Assert(StateMachineHelpers.IsRootState(state));
StateMachineExecutionState executionState = (StateMachineExecutionState)state.GetValue(StateActivity.StateMachineExecutionStateProperty);
Debug.Assert(executionState != null);
return(executionState);
}
private static StateMachineExecutionState GetExecutionState(StateActivity state)
{
if (state == null)
{
throw new ArgumentNullException("state");
}
return(StateMachineExecutionState.Get(StateMachineHelpers.GetRootState(state)));
}
private static StateFinalizationActivity GetStateFinalization(ActivityExecutionContext context)
{
StateActivity state = (StateActivity)context.Activity;
Debug.Assert(StateMachineHelpers.IsLeafState(state),
"GetStateFinalization: StateFinalization is only allowed in a leaf node state");
return(GetHandlerActivity <StateFinalizationActivity>(context));
}
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 void DeleteQueue(ActivityExecutionContext context)
{
if (StateMachineHelpers.IsRootExecutionContext(context))
{
WorkflowQueuingService service = context.GetService <WorkflowQueuingService>();
service.GetWorkflowQueue("SetStateQueue");
service.DeleteWorkflowQueue("SetStateQueue");
}
}
internal void SubscribeEventDriven(ActivityExecutionContext context, EventDrivenActivity eventDriven)
{
IEventActivity eventActivity = StateMachineHelpers.GetEventActivity(eventDriven);
Activity activity = (Activity)eventActivity;
IComparable queueName = GetQueueName(eventActivity);
Debug.Assert(!this.Subscriptions.ContainsKey(queueName));
SubscribeEventActivity(context, eventActivity);
}
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 void ProcessQueue(ActivityExecutionContext context)
{
StateActivity currentState = StateMachineHelpers.GetCurrentState(context);
if (((this.EventQueue.Count != 0) && !this.ExecutionState.HasEnqueuedActions) && (!this.ExecutionState.SchedulerBusy && (currentState != null)))
{
this.Dequeue().ProcessEvent(context);
}
}
/// <summary>
///
/// </summary>
/// <param name="state"></param>
/// <returns></returns>
private static void ValidateRootState(StateActivity state, ValidationErrorCollection validationErrors)
{
ValidateCompositeStateChildren(state, validationErrors);
if (StateMachineHelpers.IsStateMachine(state))
{
ValidateInitialState(state, validationErrors);
ValidateCompletedState(state, validationErrors);
}
}
internal static IEnumerable GetPreceedingActivities(Activity startActivity, bool crossOverLoop)
{
Activity activity = null;
Stack <Activity> iteratorVariable1 = new Stack <Activity>();
iteratorVariable1.Push(startActivity);
while ((activity = iteratorVariable1.Pop()) != null)
{
if ((activity is CompositeActivity) && Helpers.IsCustomActivity((CompositeActivity)activity))
{
break;
}
if (activity.Parent != null)
{
foreach (Activity iteratorVariable2 in activity.Parent.Activities)
{
if (((iteratorVariable2 == activity) && (((activity.Parent is ParallelActivity) && !Helpers.IsFrameworkActivity(activity)) || ((activity.Parent is StateActivity) && !Helpers.IsFrameworkActivity(activity)))) || (((activity.Parent is IfElseActivity) && !Helpers.IsFrameworkActivity(activity)) || ((activity.Parent is ListenActivity) && !Helpers.IsFrameworkActivity(activity))))
{
continue;
}
StateActivity parent = activity.Parent as StateActivity;
if (parent != null)
{
StateActivity state = StateMachineHelpers.FindEnclosingState(startActivity);
if (StateMachineHelpers.IsInitialState(state))
{
break;
}
yield return(parent);
}
if (iteratorVariable2 == activity)
{
break;
}
if (iteratorVariable2.Enabled)
{
if (((iteratorVariable2 is CompositeActivity) && !Helpers.IsCustomActivity((CompositeActivity)iteratorVariable2)) && (crossOverLoop || !IsLoopActivity(iteratorVariable2)))
{
IEnumerator enumerator = GetContainedActivities((CompositeActivity)iteratorVariable2).GetEnumerator();
while (enumerator.MoveNext())
{
Activity current = (Activity)enumerator.Current;
yield return(current);
}
continue;
}
yield return(iteratorVariable2);
}
}
}
if (!crossOverLoop && IsLoopActivity(activity.Parent))
{
break;
}
iteratorVariable1.Push(activity.Parent);
}
}
internal void ProcessTransitionRequest(ActivityExecutionContext context)
{
if (!string.IsNullOrEmpty(this.NextStateName))
{
StateActivity currentState = StateMachineHelpers.GetCurrentState(context);
this.CalculateStateTransition(currentState, this.NextStateName);
this.LockQueue();
this.NextStateName = null;
}
}
internal void CreateQueue(ActivityExecutionContext context)
{
if (StateMachineHelpers.IsRootExecutionContext(context))
{
WorkflowQueuingService service = context.GetService <WorkflowQueuingService>();
MessageEventSubscription subscription = new MessageEventSubscription("SetStateQueue", this._instanceId);
service.CreateWorkflowQueue("SetStateQueue", true);
base.SubscriptionId = subscription.SubscriptionId;
}
}
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);
}
private void PopulateDropDownList(ListBox dropDownList, Activity activity)
{
StateActivity state = StateMachineHelpers.FindEnclosingState(activity);
if (state != null)
{
StateActivity rootState = StateMachineHelpers.GetRootState(state);
this.FindStates(dropDownList, rootState);
}
}
