protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } Activity bodyActivity = this.BodyActivity; System.Workflow.Activities.EventHandlersActivity eventHandlersActivity = this.EventHandlersActivity; if ((bodyActivity == null) && (eventHandlersActivity == null)) { return(ActivityExecutionStatus.Closed); } bool flag = false; if ((bodyActivity != null) && (bodyActivity.ExecutionStatus == ActivityExecutionStatus.Executing)) { executionContext.CancelActivity(bodyActivity); flag = true; } if ((eventHandlersActivity != null) && (eventHandlersActivity.ExecutionStatus == ActivityExecutionStatus.Executing)) { executionContext.CancelActivity(eventHandlersActivity); flag = true; } if ((!flag && ((bodyActivity == null) || ((bodyActivity.ExecutionStatus != ActivityExecutionStatus.Faulting) && (bodyActivity.ExecutionStatus != ActivityExecutionStatus.Canceling)))) && ((eventHandlersActivity == null) || ((eventHandlersActivity.ExecutionStatus != ActivityExecutionStatus.Faulting) && (eventHandlersActivity.ExecutionStatus != ActivityExecutionStatus.Canceling)))) { return(ActivityExecutionStatus.Closed); } return(base.ExecutionStatus); }
/// <summary> /// Called by the workflow runtime to cancel execution of an activity that is currently executing. /// </summary> /// <param name="executionContext">The <see cref="T:System.Workflow.ComponentModel.ActivityExecutionContext"/> containing the instance to cancel.</param> /// <returns> /// The status at the end of the operation, which determines whether the activity remains in the canceling state, or transitions to the closed state. /// </returns> protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } bool flag = true; for (int i = 0; i < base.EnabledActivities.Count; i++) { Activity activity = base.EnabledActivities[i]; if (activity.ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(activity); flag = false; } else if ((activity.ExecutionStatus == ActivityExecutionStatus.Canceling) || (activity.ExecutionStatus == ActivityExecutionStatus.Faulting)) { flag = false; } } if (!flag) { return(ActivityExecutionStatus.Canceling); } return(ActivityExecutionStatus.Closed); }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { bool flag = true; for (int i = 0; i < base.EnabledActivities.Count; i++) { Activity activity = base.EnabledActivities[i]; if (activity.ExecutionStatus == ActivityExecutionStatus.Executing) { flag = false; executionContext.CancelActivity(activity); break; } if ((activity.ExecutionStatus == ActivityExecutionStatus.Canceling) || (activity.ExecutionStatus == ActivityExecutionStatus.Faulting)) { flag = false; break; } } if (!flag) { return(ActivityExecutionStatus.Canceling); } return(ActivityExecutionStatus.Closed); }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (null == executionContext) { throw new ArgumentNullException("executionContext"); } bool cancelled = true; // Check all children to ensure that they are cancelled for (int childNum = 0; childNum < this.EnabledActivities.Count; childNum++) { Activity child = this.EnabledActivities[childNum]; if (child.ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(child); cancelled = false; } else if ((child.ExecutionStatus == ActivityExecutionStatus.Canceling) || (child.ExecutionStatus == ActivityExecutionStatus.Faulting)) { cancelled = false; } } return(cancelled ? ActivityExecutionStatus.Canceling : ActivityExecutionStatus.Closed); }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } for (int i = base.EnabledActivities.Count - 1; i >= 0; i--) { Activity activity = base.EnabledActivities[i]; if (activity.ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(activity); return(ActivityExecutionStatus.Canceling); } if ((activity.ExecutionStatus == ActivityExecutionStatus.Canceling) || (activity.ExecutionStatus == ActivityExecutionStatus.Faulting)) { return(ActivityExecutionStatus.Canceling); } if (activity.ExecutionStatus == ActivityExecutionStatus.Closed) { base.RemoveProperty(ActiveChildQualifiedNameProperty); return(ActivityExecutionStatus.Closed); } } return(ActivityExecutionStatus.Closed); }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } bool canCloseNow = true; for (int i = 0; i < this.EnabledActivities.Count; ++i) { Activity childActivity = this.EnabledActivities[i]; if (childActivity.ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(childActivity); canCloseNow = false; } else if (childActivity.ExecutionStatus == ActivityExecutionStatus.Canceling || childActivity.ExecutionStatus == ActivityExecutionStatus.Faulting) { canCloseNow = false; } } return(canCloseNow ? ActivityExecutionStatus.Closed : ActivityExecutionStatus.Canceling); }
private bool TryCancelChild(ActivityExecutionContext outerProvider, ChildExecutionStateInfo childStateInfo) { bool flag = false; ActivityExecutionContextManager executionContextManager = outerProvider.ExecutionContextManager; ActivityExecutionContext executionContext = this.GetExecutionContext(executionContextManager, childStateInfo.RunId); if (executionContext != null) { switch (executionContext.Activity.ExecutionStatus) { case ActivityExecutionStatus.Executing: executionContext.CancelActivity(executionContext.Activity); return(true); case ActivityExecutionStatus.Canceling: case ActivityExecutionStatus.Faulting: return(true); case ActivityExecutionStatus.Closed: case ActivityExecutionStatus.Compensating: return(flag); } return(flag); } if ((base.ExecutionStatus != ActivityExecutionStatus.Executing) && (childStateInfo.Status == ChildRunStatus.PendingExecute)) { childStateInfo.Status = ChildRunStatus.Completed; } return(flag); }
/// <summary> /// Cancel the activity. Loop through all enabled activities, and for any that are currently /// executing ask them to cancel. /// </summary> /// <param name="executionContext"></param> /// <returns>The status of the activity</returns> protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (null == executionContext) { throw new ArgumentNullException("executionContext"); } bool completed = true; for (int pos = 0; pos < base.EnabledActivities.Count; pos++) { Activity act = base.EnabledActivities[pos]; if (act.ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(act); completed = false; } else if ((act.ExecutionStatus == ActivityExecutionStatus.Canceling) || (act.ExecutionStatus == ActivityExecutionStatus.Faulting)) { completed = false; } } if (!completed) { return(ActivityExecutionStatus.Canceling); } else { return(ActivityExecutionStatus.Closed); } }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } if (this.EnabledActivities.Count == 0) { return(ActivityExecutionStatus.Closed); } Activity childActivity = this.EnabledActivities[0]; ActivityExecutionContextManager contextManager = executionContext.ExecutionContextManager; ActivityExecutionContext childContext = contextManager.GetExecutionContext(childActivity); if (childContext != null) { if (childContext.Activity.ExecutionStatus == ActivityExecutionStatus.Executing) { childContext.CancelActivity(childContext.Activity); } return(ActivityExecutionStatus.Canceling); } return(ActivityExecutionStatus.Closed); }
/// <summary> /// This override function cancels the execution of the child activity if cancel is called /// on the ForEach activity itself. /// </summary> /// <param name="context"></param> /// <returns></returns> protected override ActivityExecutionStatus Cancel(ActivityExecutionContext context) { if (context == null) { throw new ArgumentNullException("activity execution context is null."); } // If there is no child activity, the ForEach activity is closed. if (this.EnabledActivities.Count == 0) { return(ActivityExecutionStatus.Closed); } Activity childActivity = this.EnabledActivities[0]; ActivityExecutionContext childContext = context.ExecutionContextManager.GetExecutionContext(childActivity); if (childContext != null) { if (childContext.Activity.ExecutionStatus == ActivityExecutionStatus.Executing) { // Cancel the executing child activity. childContext.CancelActivity(childContext.Activity); } return(ActivityExecutionStatus.Canceling); } return(ActivityExecutionStatus.Closed); }
public static ActivityExecutionStatus Cancel(CompositeActivity activity, ActivityExecutionContext executionContext) { for (int i = (activity.EnabledActivities.Count - 1); i >= 0; i--) { Activity childActivity = activity.EnabledActivities[i]; if (childActivity.ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(childActivity); return activity.ExecutionStatus; } if (childActivity.ExecutionStatus == ActivityExecutionStatus.Canceling || childActivity.ExecutionStatus == ActivityExecutionStatus.Faulting) { return activity.ExecutionStatus; } if (childActivity.ExecutionStatus == ActivityExecutionStatus.Closed) { activity.RemoveProperty(ActiveChildQualifiedNameProperty); return ActivityExecutionStatus.Closed; } } return ActivityExecutionStatus.Closed; }
internal bool Cleanup(ConditionedActivityGroup cag, ActivityExecutionContext context) { // the completion condition has fired, or we are canceling // either way, we want to cleanup ConditionedActivityGroupStateInfo state = cag.CAGState; state.Completed = true; // cancel any children currently running bool childrenActive = false; Dictionary <string, CAGChildStats> childrenStats = state.ChildrenStats; foreach (Activity act in cag.EnabledActivities) { // reset any Pending Execution for all child activity if (childrenStats[act.QualifiedName].State == CAGChildState.Pending) { childrenStats[act.QualifiedName].State = CAGChildState.Idle; } // find the run-time activity ActivityExecutionContext childContext = GetChildExecutionContext(context, act, false); if (childContext != null) { // child must be running somewhere Activity activity = GetRuntimeInitializedActivity(context, act); switch (activity.ExecutionStatus) { case ActivityExecutionStatus.Executing: // schedule cancellation on child childContext.CancelActivity(activity); childrenActive = true; break; case ActivityExecutionStatus.Canceling: case ActivityExecutionStatus.Faulting: childrenActive = true; break; case ActivityExecutionStatus.Closed: CleanupChildAtClosure(context, activity); break; default: // unhook our handler // others will be removed when we get the complete/cancel notification act.UnregisterForStatusChange(Activity.ClosedEvent, this); break; } } } // if the CAG is quiet, we are all done if (!childrenActive) { context.CloseActivity(); } return(!childrenActive); }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } if (this.ActivityState == null) { return(ActivityExecutionStatus.Closed); } bool scopeCompleted = this.IsScopeCompleted; bool canCloseNow = true; for (int i = 0; i < this.EnabledActivities.Count; ++i) { EventDrivenActivity childActivity = this.EnabledActivities[i] as EventDrivenActivity; EventHandlerEventActivitySubscriber eventActivitySubscriber = this.ActivityState[i] as EventHandlerEventActivitySubscriber; eventActivitySubscriber.PendingExecutionCount = 0; ActivityExecutionContextManager contextManager = executionContext.ExecutionContextManager; ActivityExecutionContext childContext = contextManager.GetExecutionContext(childActivity); if (childContext != null) { switch (childContext.Activity.ExecutionStatus) { case ActivityExecutionStatus.Canceling: case ActivityExecutionStatus.Faulting: canCloseNow = false; break; case ActivityExecutionStatus.Executing: childContext.CancelActivity(childContext.Activity); canCloseNow = false; break; } } if (!scopeCompleted) //UnSubscribe from event. { childActivity.EventActivity.Unsubscribe(executionContext, eventActivitySubscriber); } } if (canCloseNow) { this.ActivityState = null; return(ActivityExecutionStatus.Closed); } else { return(this.ExecutionStatus); } }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } Activity bodyActivity = this.BodyActivity; EventHandlersActivity eventHandlers = this.EventHandlersActivity; if (bodyActivity == null && eventHandlers == null) { return(ActivityExecutionStatus.Closed); } bool cancelScheduled = false; // check the status of body if (bodyActivity != null && bodyActivity.ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(bodyActivity); cancelScheduled = true; } //Check the status of EventHandlers if (eventHandlers != null && eventHandlers.ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(eventHandlers); cancelScheduled = true; } if (cancelScheduled || (bodyActivity != null && (bodyActivity.ExecutionStatus == ActivityExecutionStatus.Faulting || bodyActivity.ExecutionStatus == ActivityExecutionStatus.Canceling)) || (eventHandlers != null && (eventHandlers.ExecutionStatus == ActivityExecutionStatus.Faulting || eventHandlers.ExecutionStatus == ActivityExecutionStatus.Canceling)) ) { return(this.ExecutionStatus); } return(ActivityExecutionStatus.Closed); }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } if (this.ActivityState == null) { return(ActivityExecutionStatus.Closed); } try { if (this.IsListenTrigerred) { //We need to cancel the active running branch for (int i = 0; i < this.EnabledActivities.Count; ++i) { EventDrivenActivity eventDriven = this.EnabledActivities[i] as EventDrivenActivity; if (eventDriven.ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(eventDriven); return(ActivityExecutionStatus.Canceling); } //If the branch is faulting let it close. else if (eventDriven.ExecutionStatus == ActivityExecutionStatus.Faulting) { return(ActivityExecutionStatus.Canceling); } } } else { //Everything is passive. Lets unsubscribe all and close. for (int i = 0; i < this.ActivityState.Count; ++i) { EventDrivenActivity eventDrivenChild = this.EnabledActivities[i] as EventDrivenActivity; ListenEventActivitySubscriber eventActivitySubscriber = this.ActivityState[i]; eventDrivenChild.EventActivity.Unsubscribe(executionContext, eventActivitySubscriber); } } } finally { // We null out ActivityState in the finally block to ensure that if // eventDrivenChild.EventActivity.Unsubscribe above throws then the // Cancel method does not get called repeatedly. this.ActivityState = null; } return(ActivityExecutionStatus.Closed); }
public ActivityExecutionStatus Cancel() { using (ActivityExecutionContext context = new ActivityExecutionContext(this.rootActivity, true)) { if (this.rootActivity.ExecutionStatus == ActivityExecutionStatus.Executing) { context.CancelActivity(this.rootActivity); } } this.scheduler.Run(); return(this.TranslateExecutionStatus()); }
/// <summary> /// Processes the closed even for any activities. /// </summary> /// <param name="executionContext">The execution context.</param> /// <param name="closedActivity">The closed activity.</param> /// <returns></returns> private ActivityExecutionStatus ProcessClosedEvenForAnyActivities(ActivityExecutionContext executionContext, Activity closedActivity) { for (int i = 0; i < base.EnabledActivities.Count; i++) { Activity activity = base.EnabledActivities[i]; if (base.EnabledActivities[i].ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(activity); } } return(ActivityExecutionStatus.Closed); }
internal bool Cleanup(ConditionedActivityGroup cag, ActivityExecutionContext context) { ConditionedActivityGroupStateInfo cAGState = cag.CAGState; cAGState.Completed = true; bool flag = false; Dictionary <string, CAGChildStats> childrenStats = cAGState.ChildrenStats; foreach (Activity activity in cag.EnabledActivities) { if (childrenStats[activity.QualifiedName].State == CAGChildState.Pending) { childrenStats[activity.QualifiedName].State = CAGChildState.Idle; } ActivityExecutionContext context2 = GetChildExecutionContext(context, activity, false); if (context2 != null) { Activity runtimeInitializedActivity = this.GetRuntimeInitializedActivity(context, activity); switch (runtimeInitializedActivity.ExecutionStatus) { case ActivityExecutionStatus.Executing: { context2.CancelActivity(runtimeInitializedActivity); flag = true; continue; } case ActivityExecutionStatus.Canceling: case ActivityExecutionStatus.Faulting: { flag = true; continue; } case ActivityExecutionStatus.Closed: { this.CleanupChildAtClosure(context, runtimeInitializedActivity); continue; } } activity.UnregisterForStatusChange(Activity.ClosedEvent, this); } } if (!flag) { context.CloseActivity(); } return(!flag); }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } if (this.ActivityState == null) { return(ActivityExecutionStatus.Closed); } bool isScopeCompleted = this.IsScopeCompleted; bool flag2 = true; for (int i = 0; i < base.EnabledActivities.Count; i++) { EventDrivenActivity activity = base.EnabledActivities[i] as EventDrivenActivity; EventHandlerEventActivitySubscriber parentEventHandler = this.ActivityState[i]; parentEventHandler.PendingExecutionCount = 0; ActivityExecutionContext context = executionContext.ExecutionContextManager.GetExecutionContext(activity); if (context != null) { switch (context.Activity.ExecutionStatus) { case ActivityExecutionStatus.Executing: context.CancelActivity(context.Activity); flag2 = false; break; case ActivityExecutionStatus.Canceling: case ActivityExecutionStatus.Faulting: flag2 = false; break; } } if (!isScopeCompleted) { activity.EventActivity.Unsubscribe(executionContext, parentEventHandler); } } if (flag2) { this.ActivityState = null; return(ActivityExecutionStatus.Closed); } return(base.ExecutionStatus); }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } if (this.ActivityState != null) { try { if (this.IsListenTrigerred) { for (int i = 0; i < base.EnabledActivities.Count; i++) { EventDrivenActivity activity = base.EnabledActivities[i] as EventDrivenActivity; if (activity.ExecutionStatus == ActivityExecutionStatus.Executing) { executionContext.CancelActivity(activity); return(ActivityExecutionStatus.Canceling); } if (activity.ExecutionStatus == ActivityExecutionStatus.Faulting) { return(ActivityExecutionStatus.Canceling); } } } else { for (int j = 0; j < this.ActivityState.Count; j++) { EventDrivenActivity activity2 = base.EnabledActivities[j] as EventDrivenActivity; ListenEventActivitySubscriber parentEventHandler = this.ActivityState[j]; activity2.EventActivity.Unsubscribe(executionContext, parentEventHandler); } } } finally { this.ActivityState = null; } } return(ActivityExecutionStatus.Closed); }
bool TryCancelChild(ActivityExecutionContext outerProvider, ChildExecutionStateInfo childStateInfo) { // schedule cancellation of the child in the inner execution context bool fScheduledCancel = false; // returns true iff scheduled cancel on one execution of the template // false if execution already closed // get the execution context for this run ActivityExecutionContextManager contextManager = outerProvider.ExecutionContextManager; ActivityExecutionContext innerProvider = GetExecutionContext(contextManager, childStateInfo.RunId); if (innerProvider != null) { switch (innerProvider.Activity.ExecutionStatus) { case ActivityExecutionStatus.Executing: // schedule cancellation on child innerProvider.CancelActivity(innerProvider.Activity); fScheduledCancel = true; break; case ActivityExecutionStatus.Canceling: case ActivityExecutionStatus.Faulting: fScheduledCancel = true; break; default: // do nothing break; } } else { //Finish the run if it is pending for execution. if (this.ExecutionStatus != ActivityExecutionStatus.Executing && childStateInfo.Status == ChildRunStatus.PendingExecute) { childStateInfo.Status = ChildRunStatus.Completed; } } return(fScheduledCancel); }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { ActivityExecutionStatus __status = ActivityExecutionStatus.Closed; foreach (IfElseBranchActivityCustom branch in this.EnabledActivities) { if (branch.ExecutionStatus == ActivityExecutionStatus.Executing) { __status = ActivityExecutionStatus.Canceling; executionContext.CancelActivity(branch); break; } if ((branch.ExecutionStatus == ActivityExecutionStatus.Canceling) || (branch.ExecutionStatus == ActivityExecutionStatus.Faulting)) { __status = ActivityExecutionStatus.Canceling; break; } } return(__status); }
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext) { bool canCloseNow = true; for (int i = 0; i < this.EnabledActivities.Count; ++i) { Activity childBranch = this.EnabledActivities[i]; if (childBranch.ExecutionStatus == ActivityExecutionStatus.Executing) { canCloseNow = false; executionContext.CancelActivity(childBranch); break; } else if (childBranch.ExecutionStatus == ActivityExecutionStatus.Canceling || childBranch.ExecutionStatus == ActivityExecutionStatus.Faulting) { canCloseNow = false; break; } } return(canCloseNow ? ActivityExecutionStatus.Closed : ActivityExecutionStatus.Canceling); }
public ActivityExecutionStatus Cancel() { using (ActivityExecutionContext activityExecutionContext = new ActivityExecutionContext(this.rootActivity, true)) { if (this.rootActivity.ExecutionStatus == ActivityExecutionStatus.Executing) { activityExecutionContext.CancelActivity(this.rootActivity); } } scheduler.Run(); return TranslateExecutionStatus(); }