void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e) { ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException(); } e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); if (e.Activity is EventHandlersActivity) { if (this.BodyActivity.ExecutionStatus == ActivityExecutionStatus.Closed) { context.CloseActivity(); } //else Eventhandlers faulted, let exception propagate up. } else { EventHandlersActivity eventHandlers = this.EventHandlersActivity; if (eventHandlers == null || eventHandlers.ExecutionStatus == ActivityExecutionStatus.Closed) { context.CloseActivity(); } else { eventHandlers.UnsubscribeAndClose(); } } }
/// <summary> /// Defines the processing procedure when the subscribed-to event occurs. /// </summary> /// <param name="sender">The object that raised the event.</param> /// <param name="e">The previously typed event arguments.</param> void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e) { ActivityExecutionContext ctx = sender as ActivityExecutionContext; if (ctx != null && this.ExecutionStatus == ActivityExecutionStatus.Executing) { try { ActivityExecutionStatus status = ProcessQueueElement(ctx); if (status == ActivityExecutionStatus.Closed) { UnsubscribeFromQueueItemAvailable(ctx); ctx.CloseActivity(); } else if (status == ActivityExecutionStatus.Canceling) { UnsubscribeFromQueueItemAvailable(ctx); ctx.CloseActivity(); throw new CustomWorkflowTerminateException(BusinessProcessExecutionResult.Declined); } } finally { } } }
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e) { ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException(); } e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); if (e.Activity is System.Workflow.Activities.EventHandlersActivity) { if (this.BodyActivity.ExecutionStatus == ActivityExecutionStatus.Closed) { context.CloseActivity(); } } else { System.Workflow.Activities.EventHandlersActivity eventHandlersActivity = this.EventHandlersActivity; if ((eventHandlersActivity == null) || (eventHandlersActivity.ExecutionStatus == ActivityExecutionStatus.Closed)) { context.CloseActivity(); } else { eventHandlersActivity.UnsubscribeAndClose(); } } }
protected override void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext) { String activeChildQualifiedName = this.GetValue(ActiveChildQualifiedNameProperty) as String; if (activeChildQualifiedName != null && activeChildRemovedInDynamicUpdate) { //We have our active child removed. if (this.ExecutionStatus == ActivityExecutionStatus.Canceling || (this.ExecutionStatus == ActivityExecutionStatus.Faulting) && (bool)this.GetValue(SequenceFaultingProperty)) { if (this.ExecutionStatus == ActivityExecutionStatus.Faulting) { this.RemoveProperty(SequenceFaultingProperty); } this.RemoveProperty(ActiveChildQualifiedNameProperty); executionContext.CloseActivity(); } else if (this.ExecutionStatus == ActivityExecutionStatus.Executing) { if (!TryScheduleNextChild(executionContext)) { OnSequenceComplete(executionContext); executionContext.CloseActivity(); } } } activeChildRemovedInDynamicUpdate = false; base.OnWorkflowChangesCompleted(executionContext); }
protected override void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } base.OnWorkflowChangesCompleted(executionContext); if (this.ActivityState != null) { switch (base.ExecutionStatus) { case ActivityExecutionStatus.Executing: if (this.IsScopeCompleted && this.AllHandlersAreQuiet(this, executionContext)) { executionContext.CloseActivity(); } return; case ActivityExecutionStatus.Canceling: case ActivityExecutionStatus.Faulting: if (this.AllHandlersAreQuiet(this, executionContext)) { executionContext.CloseActivity(); } return; case ActivityExecutionStatus.Closed: case ActivityExecutionStatus.Compensating: return; } } }
protected override void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext) { base.OnWorkflowChangesCompleted(executionContext); switch (this.ExecutionStatus) { case ActivityExecutionStatus.Executing: if (bodyActivityRemovedInDynamicUpdate) { if (EventHandlersActivity == null || EventHandlersActivity.ExecutionStatus == ActivityExecutionStatus.Closed) { executionContext.CloseActivity(); } else if (EventHandlersActivity.ExecutionStatus == ActivityExecutionStatus.Executing) { EventHandlersActivity.UnsubscribeAndClose(); } } if (eventHandlersRemovedInDynamicUpdate) { if (BodyActivity == null || BodyActivity.ExecutionStatus == ActivityExecutionStatus.Closed) { executionContext.CloseActivity(); } } break; default: break; } eventHandlersRemovedInDynamicUpdate = false; bodyActivityRemovedInDynamicUpdate = false; }
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(Object sender, ActivityExecutionStatusChangedEventArgs e) { if (sender == null) { throw new ArgumentNullException("sender"); } if (e == null) { throw new ArgumentNullException("e"); } ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender"); } e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); SequenceActivity sequenceActivity = context.Activity as SequenceActivity; if (sequenceActivity == null) { throw new ArgumentException("sender"); } if (sequenceActivity.ExecutionStatus == ActivityExecutionStatus.Canceling || (sequenceActivity.ExecutionStatus == ActivityExecutionStatus.Faulting) && (bool)this.GetValue(SequenceFaultingProperty)) { if (sequenceActivity.ExecutionStatus == ActivityExecutionStatus.Faulting) { this.RemoveProperty(SequenceFaultingProperty); } this.RemoveProperty(ActiveChildQualifiedNameProperty); context.CloseActivity(); } else if (sequenceActivity.ExecutionStatus == ActivityExecutionStatus.Executing) { if (!TryScheduleNextChild(context)) { OnSequenceComplete(context); context.CloseActivity(); } } }
void q_QueueItemAvailable(object sender, QueueEventArgs e) { ActivityExecutionContext aec = sender as ActivityExecutionContext; if (aec != null) { WorkflowQueuingService qs = aec.GetService <WorkflowQueuingService>(); WorkflowQueue q = qs.GetWorkflowQueue(e.QueueName); //get the outparameters from the workflow object o = q.Dequeue(); //delete the queue qs.DeleteWorkflowQueue(e.QueueName); Dictionary <string, object> outparams = o as Dictionary <string, object>; if (outparams != null) { foreach (KeyValuePair <string, object> item in outparams) { if (this.Parameters.Contains(item.Key)) { //modify the value this.Parameters[item.Key].SetValue(WorkflowParameterBinding.ValueProperty, item.Value); } } } aec.CloseActivity(); } }
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e) { if (e == null) { throw new ArgumentNullException("e"); } if (sender == null) { throw new ArgumentNullException("sender"); } ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender"); } e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager; executionContextManager.CompleteExecutionContext(executionContextManager.GetExecutionContext(e.Activity)); if (!this.TryNextIteration(context)) { context.CloseActivity(); } }
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e) { ActivityExecutionContext context = sender as ActivityExecutionContext; if (e.ExecutionStatus == ActivityExecutionStatus.Closed) { e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); LoggerActivity lgr = context.Activity as LoggerActivity; bool finished = true; for (int childNum = 0; childNum < lgr.EnabledActivities.Count; childNum++) { Activity child = lgr.EnabledActivities[childNum]; if ((child.ExecutionStatus != ActivityExecutionStatus. Initialized) && (child.ExecutionStatus != ActivityExecutionStatus.Closed)) { finished = false; } } if (finished) { context.CloseActivity(); } } }
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { if (executionContext == null) { throw new ArgumentNullException("executionContext"); } ActivityExecutionStatus status = ExecuteForActivity(executionContext, this.InterfaceType, this.MethodName); if (status == ActivityExecutionStatus.Closed) { UnsubscribeForActivity(executionContext); executionContext.CloseActivity(); return(status); } // cannot resolve queue name or message not available // hence subscribe for message arrival if (!this.ActivitySubscribed) { this.ActivitySubscribed = CorrelationService.Subscribe(executionContext, this, this.InterfaceType, this.MethodName, this, this.WorkflowInstanceId); } return(ActivityExecutionStatus.Executing); }
void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e) { if (sender == null) { throw new ArgumentNullException("sender"); } if (e == null) { throw new ArgumentNullException("e"); } ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender"); } if (this.ExecutionStatus != ActivityExecutionStatus.Closed) { System.Diagnostics.Debug.Assert(this.SubscriptionID != Guid.Empty); WorkflowQueuingService qService = context.GetService <WorkflowQueuingService>(); qService.GetWorkflowQueue(e.QueueName).Dequeue(); qService.DeleteWorkflowQueue(e.QueueName); context.CloseActivity(); } }
protected internal sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { executionContext.CloseActivity(); string error = this.Error; executionContext.SuspendWorkflowInstance(error); return ActivityExecutionStatus.Closed; }
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e) { if (sender == null) { throw new ArgumentNullException("sender"); } if (e == null) { throw new ArgumentNullException("e"); } ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender"); } ParallelActivity activity = context.Activity as ParallelActivity; e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); bool flag = true; for (int i = 0; i < activity.EnabledActivities.Count; i++) { Activity activity2 = activity.EnabledActivities[i]; if ((activity2.ExecutionStatus != ActivityExecutionStatus.Initialized) && (activity2.ExecutionStatus != ActivityExecutionStatus.Closed)) { flag = false; break; } } if (flag) { context.CloseActivity(); } }
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 internal override sealed ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { executionContext.CloseActivity(); string suspendReason = this.Error; executionContext.SuspendWorkflowInstance(suspendReason); return ActivityExecutionStatus.Closed; }
protected internal override sealed ActivityExecutionStatus Execute(ActivityExecutionContext executionContext) { executionContext.CloseActivity(); string terminateReason = this.Error; executionContext.TerminateWorkflowInstance(new WorkflowTerminatedException(terminateReason)); return ActivityExecutionStatus.Closed; }
protected override void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext) { base.OnWorkflowChangesCompleted(executionContext); if (this.activeBranchRemoved) { executionContext.CloseActivity(); } this.activeBranchRemoved = false; }
// When a child activity is closed, it's removed from the execution context, // and the execution proceed to the next iteration. private void OnChildClose(Object sender, ActivityExecutionStatusChangedEventArgs e) { if (e == null) { throw new ArgumentNullException("OnChildClose parameter 'e' is null."); } if (sender == null) { throw new ArgumentNullException("OnChildClose parameter 'sender' is null."); } ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException("OnChildClose parameter 'sender' is not ActivityExecutionContext."); } ForEach foreachActivity = context.Activity as ForEach; if (foreachActivity == null) { throw new ArgumentException("OnChildClose parameter 'sender' does not contain a 'ForEach' activity."); } // Remove the event handler first. e.Activity.Closed -= this.OnChildClose; // Then remove the child activity from the execution context. context.ExecutionContextManager.CompleteExecutionContext(context.ExecutionContextManager.GetExecutionContext(e.Activity)); // Move on to the next iteration. if (this.ExecutionStatus == ActivityExecutionStatus.Canceling) { context.CloseActivity(); } else if (this.ExecutionStatus == ActivityExecutionStatus.Executing) { if (!ExecuteNext(context)) { context.CloseActivity(); } } }
private void HandleExternalEvent(Object sender, QueueEventArgs args) { ThreadMonitor.WriteToConsole(Thread.CurrentThread, "WaitForMessageActivity", "WaitForMessageActivity: Processed External Event"); object data = this.workflowQueue.Dequeue(); ActivityExecutionContext context = sender as ActivityExecutionContext; context.CloseActivity(); }
void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e) { ActivityExecutionContext context = (ActivityExecutionContext)sender; WebServiceInputActivity activity = context.Activity as WebServiceInputActivity; if ((activity.ExecutionStatus == ActivityExecutionStatus.Executing) && (this.ExecuteForActivity(context, activity.InterfaceType, activity.MethodName) == ActivityExecutionStatus.Closed)) { this.UnsubscribeForActivity(context); context.CloseActivity(); } }
public static void OnWorkflowChangesCompleted(CompositeActivity activity, ActivityExecutionContext executionContext) { string str = activity.GetValue(ActiveChildQualifiedNameProperty) as string; bool flag = (bool) activity.GetValue(ActiveChildRemovedProperty); if (((str != null) && flag) && (((activity.ExecutionStatus == ActivityExecutionStatus.Canceling) || (activity.ExecutionStatus == ActivityExecutionStatus.Faulting)) || ((activity.ExecutionStatus == ActivityExecutionStatus.Executing) && !TryScheduleNextChild(activity, executionContext)))) { activity.RemoveProperty(ActiveChildQualifiedNameProperty); executionContext.CloseActivity(); } activity.RemoveProperty(ActiveChildRemovedProperty); }
protected override void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext) { if ((base.GetValue(ActiveChildQualifiedNameProperty) is string) && this.activeChildRemovedInDynamicUpdate) { if ((base.ExecutionStatus == ActivityExecutionStatus.Canceling) || ((base.ExecutionStatus == ActivityExecutionStatus.Faulting) && ((bool)base.GetValue(SequenceFaultingProperty)))) { if (base.ExecutionStatus == ActivityExecutionStatus.Faulting) { base.RemoveProperty(SequenceFaultingProperty); } base.RemoveProperty(ActiveChildQualifiedNameProperty); executionContext.CloseActivity(); } else if ((base.ExecutionStatus == ActivityExecutionStatus.Executing) && !this.TryScheduleNextChild(executionContext)) { this.OnSequenceComplete(executionContext); executionContext.CloseActivity(); } } this.activeChildRemovedInDynamicUpdate = false; base.OnWorkflowChangesCompleted(executionContext); }
private void HandleChildActivityClosed(object sender, ActivityExecutionStatusChangedEventArgs eventArgs) { ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender"); } if (eventArgs == null) { throw new ArgumentNullException("eventArgs"); } Activity childActivity = eventArgs.Activity; StateActivity activity = (StateActivity)context.Activity; GetExecutionState(context).SchedulerBusy = false; CleanupChildAtClosure(context, childActivity); switch (activity.ExecutionStatus) { case ActivityExecutionStatus.Executing: if (!(childActivity is EventDrivenActivity)) { StateInitializationActivity stateInitialization = childActivity as StateInitializationActivity; if (stateInitialization != null) { HandleStateInitializationCompleted(context, stateInitialization); return; } if (childActivity is StateFinalizationActivity) { HandleStateFinalizationCompleted(context); return; } if (childActivity is StateActivity) { HandleSubStateCompleted(context); return; } InvalidChildActivity(activity); return; } HandleEventDrivenCompleted(context); return; case ActivityExecutionStatus.Canceling: case ActivityExecutionStatus.Faulting: context.CloseActivity(); return; } throw new InvalidOperationException(SR.GetInvalidActivityStatus(context.Activity)); }
private void OnUnsubscribeAndClose(object sender, EventArgs args) { if (sender == null) { throw new ArgumentNullException("sender"); } if (args == null) { throw new ArgumentNullException("args"); } ActivityExecutionContext context = (ActivityExecutionContext)sender; if (context == null) { throw new ArgumentException("sender"); } EventHandlersActivity handlers = context.Activity as EventHandlersActivity; if (context.Activity.ExecutionStatus != ActivityExecutionStatus.Executing) { return; } Debug.Assert(!handlers.IsScopeCompleted, "Only notified of scope body completion once"); handlers.IsScopeCompleted = true; ActivityExecutionContextManager contextManager = context.ExecutionContextManager; bool readyToClose = true; for (int i = 0; i < handlers.EnabledActivities.Count; ++i) { EventDrivenActivity evtDriven = handlers.EnabledActivities[i] as EventDrivenActivity; EventHandlerEventActivitySubscriber eventSubscriber = handlers.ActivityState[i]; evtDriven.EventActivity.Unsubscribe(context, eventSubscriber); if (contextManager.GetExecutionContext(evtDriven) != null || handlers.ActivityState[i].PendingExecutionCount != 0) { readyToClose = false; } } if (readyToClose) { handlers.ActivityState = null; context.CloseActivity(); } }
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 void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext) { base.OnWorkflowChangesCompleted(executionContext); if (base.ExecutionStatus == ActivityExecutionStatus.Executing) { if (this.bodyActivityRemovedInDynamicUpdate) { if ((this.EventHandlersActivity == null) || (this.EventHandlersActivity.ExecutionStatus == ActivityExecutionStatus.Closed)) { executionContext.CloseActivity(); } else if (this.EventHandlersActivity.ExecutionStatus == ActivityExecutionStatus.Executing) { this.EventHandlersActivity.UnsubscribeAndClose(); } } if (this.eventHandlersRemovedInDynamicUpdate && ((this.BodyActivity == null) || (this.BodyActivity.ExecutionStatus == ActivityExecutionStatus.Closed))) { executionContext.CloseActivity(); } } this.eventHandlersRemovedInDynamicUpdate = false; this.bodyActivityRemovedInDynamicUpdate = false; }
void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e) { Console.WriteLine("OnQueueItemAvailable #1"); // If activity is not scheduled for execution, do nothing if (this.ExecutionStatus == ActivityExecutionStatus.Executing) { Console.WriteLine("OnQueueItemAvailable #2"); ActivityExecutionContext context = sender as ActivityExecutionContext; if (this.ProcessQueueItem(context)) { context.CloseActivity(); } } }
void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e) { ActivityExecutionContext context = (ActivityExecutionContext)sender; HandleExternalEventActivity activity = context.Activity as HandleExternalEventActivity; if (activity.ExecutionStatus == ActivityExecutionStatus.Executing) { object[] args = null; if (InboundActivityHelper.ExecuteForActivity(this, context, this.InterfaceType, this.EventName, out args) == ActivityExecutionStatus.Closed) { this.RaiseEvent(args); this.UnsubscribeForActivity(context); context.CloseActivity(); } } }
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(); }
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e) { if (sender == null) { throw new ArgumentNullException("sender"); } if (e == null) { throw new ArgumentNullException("e"); } ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender"); } context.CloseActivity(); }
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e) { if (sender == null) { throw new ArgumentNullException("sender"); } if (e == null) { throw new ArgumentNullException("e"); } ActivityExecutionContext context = sender as ActivityExecutionContext; if (context == null) { throw new ArgumentException("Sender must be ActivityExecutionContext", "sender"); } BlockActivity activity = context.Activity as BlockActivity; e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this); ActivityExecutionStatus result = ActivityExecutionStatus.Initialized; switch (this.Type) { case BlockActivityType.All: result = ProcessClosedEvenForAllActivities(context, e.Activity); break; case BlockActivityType.Any: result = ProcessClosedEvenForAnyActivities(context, e.Activity); break; default: throw new ArgumentOutOfRangeException("Unknown Type"); } if (result == ActivityExecutionStatus.Closed) { context.CloseActivity(); } }
void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e) { ActivityExecutionContext context = (ActivityExecutionContext)sender; WebServiceInputActivity activity = context.Activity as WebServiceInputActivity; // if activity is not scheduled for execution do not dequeue the message if (activity.ExecutionStatus != ActivityExecutionStatus.Executing) { return; } ActivityExecutionStatus status = ExecuteForActivity(context, activity.InterfaceType, activity.MethodName); if (status == ActivityExecutionStatus.Closed) { UnsubscribeForActivity(context); context.CloseActivity(); } }
public void OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e) { if (sender == null) { throw new ArgumentNullException("sender"); } if (e == null) { throw new ArgumentNullException("e"); } ActivityExecutionContext __context = sender as ActivityExecutionContext; if (__context == null) { // TODO : Get the exception message from the System.Workflow.Activities.StringResources.resources resource file. throw new ArgumentException("The sender parameter must be of type ActivityExecutionContext."); } __context.CloseActivity(); }
// This function executes the ForEach activity. It advances the current index of the collection. // If the end of the collection is reached, return false. Otherwise, it executes any child activity // and return true. private bool ExecuteNext(ActivityExecutionContext context) { // First, move to the next position. if (!this.Enumerator.MoveNext()) return false; // Fire the Iterating event. base.RaiseEvent(IteratingEvent, this, EventArgs.Empty); // Execute the child activity. if (this.EnabledActivities.Count > 0) { // Add the child activity to the execution context and setup the event handler to // listen to the child Close event. // A new instance of the child activity is created for each iteration. ActivityExecutionContext innerContext = context.ExecutionContextManager.CreateExecutionContext(this.EnabledActivities[0]); innerContext.Activity.Closed += this.OnChildClose; // Execute the child activity again. innerContext.ExecuteActivity(innerContext.Activity); } else { // an empty foreach loop. // If the ForEach activity is still executing, then execute the next one. if (this.ExecutionStatus == ActivityExecutionStatus.Executing) { if (!ExecuteNext(context)) context.CloseActivity(); } } return true; }
public static void OnWorkflowChangesCompleted(CompositeActivity activity, ActivityExecutionContext executionContext) { String activeChildQualifiedName = activity.GetValue(ActiveChildQualifiedNameProperty) as String; bool activeChildRemovedInDynamicUpdate = (bool)activity.GetValue(ActiveChildRemovedProperty); if (activeChildQualifiedName != null && activeChildRemovedInDynamicUpdate) { //We have our active child removed. if (activity.ExecutionStatus == ActivityExecutionStatus.Canceling || activity.ExecutionStatus == ActivityExecutionStatus.Faulting || activity.ExecutionStatus == ActivityExecutionStatus.Executing && !TryScheduleNextChild(activity, executionContext)) { activity.RemoveProperty(ActiveChildQualifiedNameProperty); executionContext.CloseActivity(); } } activity.RemoveProperty(ActiveChildRemovedProperty); }
public override bool Run(IWorkflowCoreRuntime workflowCoreRuntime) { // get state reader Activity contextActivity = workflowCoreRuntime.GetContextActivityForId(this.ContextId); Activity activity = contextActivity.GetActivityByName(this.activityName); using (workflowCoreRuntime.SetCurrentActivity(activity)) { using (ActivityExecutionContext activityExecutionContext = new ActivityExecutionContext(activity)) { ActivityExecutor activityExecutor = ActivityExecutors.GetActivityExecutor(activity); switch (this.operation) { case ActivityOperationType.Execute: if (activity.ExecutionStatus == ActivityExecutionStatus.Executing) { try { workflowCoreRuntime.RaiseActivityExecuting(activity); ActivityExecutionStatus newStatus = activityExecutor.Execute(activity, activityExecutionContext); if (newStatus == ActivityExecutionStatus.Closed) activityExecutionContext.CloseActivity(); else if (newStatus != ActivityExecutionStatus.Executing) throw new InvalidOperationException(SR.GetString(SR.InvalidExecutionStatus, activity.QualifiedName, newStatus.ToString(), ActivityExecutionStatus.Executing.ToString())); } catch (Exception e) { System.Workflow.Runtime.WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Execute of Activity {0} threw {1}", activity.QualifiedName, e.ToString()); throw; } } break; case ActivityOperationType.Cancel: if (activity.ExecutionStatus == ActivityExecutionStatus.Canceling) { try { ActivityExecutionStatus newStatus = activityExecutor.Cancel(activity, activityExecutionContext); if (newStatus == ActivityExecutionStatus.Closed) activityExecutionContext.CloseActivity(); else if (newStatus != ActivityExecutionStatus.Canceling) throw new InvalidOperationException(SR.GetString(SR.InvalidExecutionStatus, activity.QualifiedName, newStatus.ToString(), ActivityExecutionStatus.Canceling.ToString())); } catch (Exception e) { System.Workflow.Runtime.WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Cancel of Activity {0} threw {1}", activity.QualifiedName, e.ToString()); throw; } } break; case ActivityOperationType.Compensate: if (activity.ExecutionStatus == ActivityExecutionStatus.Compensating) { try { ActivityExecutionStatus newStatus = activityExecutor.Compensate(activity, activityExecutionContext); if (newStatus == ActivityExecutionStatus.Closed) activityExecutionContext.CloseActivity(); else if (newStatus != ActivityExecutionStatus.Compensating) throw new InvalidOperationException(SR.GetString(SR.InvalidExecutionStatus, activity.QualifiedName, newStatus.ToString(), ActivityExecutionStatus.Compensating.ToString())); } catch (Exception e) { System.Workflow.Runtime.WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Compensate of Activity {0} threw {1}", activity.QualifiedName, e.ToString()); throw; } } break; case ActivityOperationType.HandleFault: if (activity.ExecutionStatus == ActivityExecutionStatus.Faulting) { try { ActivityExecutionStatus newStatus = activityExecutor.HandleFault(activity, activityExecutionContext, this.exceptionToDeliver); if (newStatus == ActivityExecutionStatus.Closed) activityExecutionContext.CloseActivity(); else if (newStatus != ActivityExecutionStatus.Faulting) throw new InvalidOperationException(SR.GetString(SR.InvalidExecutionStatus, activity.QualifiedName, newStatus.ToString(), ActivityExecutionStatus.Faulting.ToString())); } catch (Exception e) { System.Workflow.Runtime.WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Compensate of Activity {0} threw {1}", activity.QualifiedName, e.ToString()); throw; } } break; } } } return true; }
public override bool Run(IWorkflowCoreRuntime workflowCoreRuntime) { Activity activityByName = workflowCoreRuntime.GetContextActivityForId(base.ContextId).GetActivityByName(this.activityName); using (workflowCoreRuntime.SetCurrentActivity(activityByName)) { using (ActivityExecutionContext context = new ActivityExecutionContext(activityByName)) { ActivityExecutor activityExecutor = ActivityExecutors.GetActivityExecutor(activityByName); switch (this.operation) { case ActivityOperationType.Execute: if (activityByName.ExecutionStatus != ActivityExecutionStatus.Executing) { goto Label_0309; } try { workflowCoreRuntime.RaiseActivityExecuting(activityByName); ActivityExecutionStatus status = activityExecutor.Execute(activityByName, context); if (status == ActivityExecutionStatus.Closed) { context.CloseActivity(); } else if (status != ActivityExecutionStatus.Executing) { throw new InvalidOperationException(SR.GetString("InvalidExecutionStatus", new object[] { activityByName.QualifiedName, status.ToString(), ActivityExecutionStatus.Executing.ToString() })); } goto Label_0309; } catch (Exception exception) { WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Execute of Activity {0} threw {1}", new object[] { activityByName.QualifiedName, exception.ToString() }); throw; } break; case ActivityOperationType.Cancel: break; case ActivityOperationType.Compensate: goto Label_01A4; case ActivityOperationType.HandleFault: goto Label_0248; default: goto Label_0309; } if (activityByName.ExecutionStatus != ActivityExecutionStatus.Canceling) { goto Label_0309; } try { ActivityExecutionStatus status2 = activityExecutor.Cancel(activityByName, context); if (status2 == ActivityExecutionStatus.Closed) { context.CloseActivity(); } else if (status2 != ActivityExecutionStatus.Canceling) { throw new InvalidOperationException(SR.GetString("InvalidExecutionStatus", new object[] { activityByName.QualifiedName, status2.ToString(), ActivityExecutionStatus.Canceling.ToString() })); } goto Label_0309; } catch (Exception exception2) { WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Cancel of Activity {0} threw {1}", new object[] { activityByName.QualifiedName, exception2.ToString() }); throw; } Label_01A4: if (activityByName.ExecutionStatus != ActivityExecutionStatus.Compensating) { goto Label_0309; } try { ActivityExecutionStatus status3 = activityExecutor.Compensate(activityByName, context); if (status3 == ActivityExecutionStatus.Closed) { context.CloseActivity(); } else if (status3 != ActivityExecutionStatus.Compensating) { throw new InvalidOperationException(SR.GetString("InvalidExecutionStatus", new object[] { activityByName.QualifiedName, status3.ToString(), ActivityExecutionStatus.Compensating.ToString() })); } goto Label_0309; } catch (Exception exception3) { WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Compensate of Activity {0} threw {1}", new object[] { activityByName.QualifiedName, exception3.ToString() }); throw; } Label_0248: if (activityByName.ExecutionStatus == ActivityExecutionStatus.Faulting) { try { ActivityExecutionStatus status4 = activityExecutor.HandleFault(activityByName, context, this.exceptionToDeliver); if (status4 == ActivityExecutionStatus.Closed) { context.CloseActivity(); } else if (status4 != ActivityExecutionStatus.Faulting) { throw new InvalidOperationException(SR.GetString("InvalidExecutionStatus", new object[] { activityByName.QualifiedName, status4.ToString(), ActivityExecutionStatus.Faulting.ToString() })); } goto Label_0309; } catch (Exception exception4) { WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Compensate of Activity {0} threw {1}", new object[] { activityByName.QualifiedName, exception4.ToString() }); throw; } } } } Label_0309: return true; }