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