protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
Activity bodyActivity = this.BodyActivity;
if (bodyActivity == null)
{
return(ActivityExecutionStatus.Closed);
}
// run EventHandlers
EventHandlersActivity eventHandlers = this.EventHandlersActivity;
if (eventHandlers != null)
{
eventHandlers.RegisterForStatusChange(Activity.ClosedEvent, this);
executionContext.ExecuteActivity(eventHandlers);
}
// run body
bodyActivity.RegisterForStatusChange(Activity.ClosedEvent, this);
executionContext.ExecuteActivity(bodyActivity);
// return the status
return(this.ExecutionStatus);
}
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 <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("sender");
}
EventHandlersActivity activityStatusChangeListener = context.Activity as EventHandlersActivity;
if ((activityStatusChangeListener.ExecutionStatus == ActivityExecutionStatus.Executing) && activityStatusChangeListener.EnabledActivities.Contains(this.eventDrivenActivity))
{
if (this.IsBlocked)
{
this.IsBlocked = false;
ActivityExecutionContext context2 = context.ExecutionContextManager.CreateExecutionContext(this.eventDrivenActivity);
context2.Activity.RegisterForStatusChange(Activity.ClosedEvent, activityStatusChangeListener);
context2.ExecuteActivity(context2.Activity);
}
else
{
this.PendingExecutionCount++;
}
}
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection errors = base.Validate(manager, obj);
EventHandlersActivity activity = obj as EventHandlersActivity;
if (activity == null)
{
throw new ArgumentException(SR.GetString("Error_UnexpectedArgumentType", new object[] { typeof(EventHandlersActivity).FullName }), "obj");
}
if (activity.Parent == null)
{
errors.Add(new ValidationError(SR.GetString("Error_MustHaveParent"), 0x522));
return(errors);
}
if (!(activity.Parent is EventHandlingScopeActivity))
{
errors.Add(new ValidationError(SR.GetString("Error_EventHandlersDeclParentNotScope", new object[] { activity.Parent.QualifiedName }), 0x522));
}
bool flag = false;
foreach (Activity activity2 in activity.EnabledActivities)
{
if (!(activity2 is EventDrivenActivity))
{
flag = true;
}
}
if (flag)
{
errors.Add(new ValidationError(SR.GetString("Error_ListenNotAllEventDriven"), 0x514));
}
return(errors);
}
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();
}
}
}
protected override void OnActivityChangeRemove(ActivityExecutionContext executionContext, Activity removedActivity)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (removedActivity == null)
{
throw new ArgumentNullException("removedActivity");
}
EventDrivenActivity activity = removedActivity as EventDrivenActivity;
EventHandlersActivity activity2 = (EventHandlersActivity)executionContext.Activity;
if (((activity2.ExecutionStatus == ActivityExecutionStatus.Executing) && (activity2.ActivityState != null)) && !activity2.IsScopeCompleted)
{
for (int i = 0; i < activity2.ActivityState.Count; i++)
{
EventHandlerEventActivitySubscriber parentEventHandler = activity2.ActivityState[i];
if (parentEventHandler.eventDrivenActivity.QualifiedName.Equals(removedActivity.QualifiedName))
{
activity.EventActivity.Unsubscribe(executionContext, parentEventHandler);
activity2.ActivityState.RemoveAt(i);
return;
}
}
}
}
protected override void OnActivityChangeRemove(ActivityExecutionContext executionContext, Activity removedActivity)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (removedActivity == null)
{
throw new ArgumentNullException("removedActivity");
}
EventDrivenActivity eda = removedActivity as EventDrivenActivity;
// find out the status of the scope
EventHandlersActivity activity = (EventHandlersActivity)executionContext.Activity as EventHandlersActivity;
if (activity.ExecutionStatus == ActivityExecutionStatus.Executing && activity.ActivityState != null && !activity.IsScopeCompleted)
{
for (int i = 0; i < activity.ActivityState.Count; ++i)
{
EventHandlerEventActivitySubscriber eventSubscriber = activity.ActivityState[i];
if (eventSubscriber.eventDrivenActivity.QualifiedName.Equals(removedActivity.QualifiedName))
{
eda.EventActivity.Unsubscribe(executionContext, eventSubscriber);
activity.ActivityState.RemoveAt(i);
return;
}
}
}
}
private bool AllHandlersAreQuiet(EventHandlersActivity handlers, ActivityExecutionContext context)
{
ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
for (int i = 0; i < handlers.EnabledActivities.Count; i++)
{
EventDrivenActivity activity = handlers.EnabledActivities[i] as EventDrivenActivity;
if ((executionContextManager.GetExecutionContext(activity) != null) || ((handlers.ActivityState != null) && (handlers.ActivityState[i].PendingExecutionCount > 0)))
{
return(false);
}
}
return(true);
}
private bool AllHandlersAreQuiet(EventHandlersActivity handlers, ActivityExecutionContext context)
{
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
for (int i = 0; i < handlers.EnabledActivities.Count; ++i)
{
EventDrivenActivity eventDriven = handlers.EnabledActivities[i] as EventDrivenActivity;
if (contextManager.GetExecutionContext(eventDriven) != null || (handlers.ActivityState != null && handlers.ActivityState[i].PendingExecutionCount > 0))
{
return(false);
}
}
return(true);
}
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();
}
}
protected override void OnActivityChangeAdd(ActivityExecutionContext executionContext, Activity addedActivity)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (addedActivity == null)
{
throw new ArgumentNullException("addedActivity");
}
EventDrivenActivity eventDriven = addedActivity as EventDrivenActivity;
EventHandlersActivity activity = (EventHandlersActivity)executionContext.Activity;
EventHandlerEventActivitySubscriber parentEventHandler = new EventHandlerEventActivitySubscriber(eventDriven);
if (((activity.ExecutionStatus == ActivityExecutionStatus.Executing) && (activity.ActivityState != null)) && !activity.IsScopeCompleted)
{
eventDriven.EventActivity.Subscribe(executionContext, parentEventHandler);
activity.ActivityState.Insert(activity.EnabledActivities.IndexOf(addedActivity), parentEventHandler);
}
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
EventHandlersActivity eventHandlers = obj as EventHandlersActivity;
if (eventHandlers == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(EventHandlersActivity).FullName), "obj");
}
if (eventHandlers.Parent == null)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_MustHaveParent), ErrorNumbers.Error_EventHandlersDeclParentNotScope));
return(validationErrors);
}
// Parent must support event handlers
if (!(eventHandlers.Parent is EventHandlingScopeActivity))
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_EventHandlersDeclParentNotScope, eventHandlers.Parent.QualifiedName), ErrorNumbers.Error_EventHandlersDeclParentNotScope));
}
bool bNotAllEventHandler = false;
foreach (Activity activity in eventHandlers.EnabledActivities)
{
if (!(activity is EventDrivenActivity))
{
bNotAllEventHandler = true;
}
}
// validate that all child activities are event driven activities.
if (bNotAllEventHandler)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_ListenNotAllEventDriven), ErrorNumbers.Error_ListenNotAllEventDriven));
}
return(validationErrors);
}
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("sender");
}
EventHandlersActivity handlers = context.Activity as EventHandlersActivity;
if (handlers.ExecutionStatus != ActivityExecutionStatus.Executing)
{
return;
}
if (!handlers.EnabledActivities.Contains(eventDrivenActivity))
{
return; //Activity is dynamically removed.
}
if (IsBlocked)
{
IsBlocked = false;
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
ActivityExecutionContext childContext = contextManager.CreateExecutionContext(eventDrivenActivity);
childContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, handlers);
childContext.ExecuteActivity(childContext.Activity);
}
else
{
PendingExecutionCount++;
}
}
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);
}
private void OnUnsubscribeAndClose(object sender, EventArgs args)
{
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (args == null)
{
throw new ArgumentNullException("args");
}
ActivityExecutionContext parentContext = (ActivityExecutionContext)sender;
if (parentContext == null)
{
throw new ArgumentException("sender");
}
EventHandlersActivity activity = parentContext.Activity as EventHandlersActivity;
if (parentContext.Activity.ExecutionStatus == ActivityExecutionStatus.Executing)
{
activity.IsScopeCompleted = true;
ActivityExecutionContextManager executionContextManager = parentContext.ExecutionContextManager;
bool flag = true;
for (int i = 0; i < activity.EnabledActivities.Count; i++)
{
EventDrivenActivity activity2 = activity.EnabledActivities[i] as EventDrivenActivity;
EventHandlerEventActivitySubscriber parentEventHandler = activity.ActivityState[i];
activity2.EventActivity.Unsubscribe(parentContext, parentEventHandler);
if ((executionContextManager.GetExecutionContext(activity2) != null) || (activity.ActivityState[i].PendingExecutionCount != 0))
{
flag = false;
}
}
if (flag)
{
activity.ActivityState = null;
parentContext.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");
}
EventDrivenActivity activity = e.Activity as EventDrivenActivity;
EventHandlersActivity handlers = context.Activity as EventHandlersActivity;
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
executionContextManager.CompleteExecutionContext(executionContextManager.GetExecutionContext(activity));
switch (handlers.ExecutionStatus)
{
case ActivityExecutionStatus.Executing:
for (int i = 0; i < handlers.EnabledActivities.Count; i++)
{
if (handlers.EnabledActivities[i].QualifiedName.Equals(activity.QualifiedName))
{
EventHandlerEventActivitySubscriber subscriber = handlers.ActivityState[i];
if (subscriber.PendingExecutionCount > 0)
{
subscriber.PendingExecutionCount--;
subscriber.IsBlocked = false;
ActivityExecutionContext context2 = executionContextManager.CreateExecutionContext(handlers.EnabledActivities[i]);
context2.Activity.RegisterForStatusChange(Activity.ClosedEvent, this);
context2.ExecuteActivity(context2.Activity);
return;
}
subscriber.IsBlocked = true;
if (handlers.IsScopeCompleted && this.AllHandlersAreQuiet(handlers, context))
{
context.CloseActivity();
return;
}
break;
}
}
return;
case ActivityExecutionStatus.Canceling:
case ActivityExecutionStatus.Faulting:
if (this.AllHandlersAreQuiet(handlers, context))
{
context.CloseActivity();
}
break;
case ActivityExecutionStatus.Closed:
case ActivityExecutionStatus.Compensating:
break;
default:
return;
}
}
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");
}
EventDrivenActivity eda = e.Activity as EventDrivenActivity;
EventHandlersActivity eventHandlers = context.Activity as EventHandlersActivity;
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
contextManager.CompleteExecutionContext(contextManager.GetExecutionContext(eda));
switch (eventHandlers.ExecutionStatus)
{
case ActivityExecutionStatus.Executing:
for (int i = 0; i < eventHandlers.EnabledActivities.Count; ++i)
{
if (eventHandlers.EnabledActivities[i].QualifiedName.Equals(eda.QualifiedName))
{
EventHandlerEventActivitySubscriber eventActivitySubscriber = eventHandlers.ActivityState[i];
if (eventActivitySubscriber.PendingExecutionCount > 0)
{
eventActivitySubscriber.PendingExecutionCount--;
eventActivitySubscriber.IsBlocked = false;
ActivityExecutionContext childContext = contextManager.CreateExecutionContext(eventHandlers.EnabledActivities[i]);
childContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, this);
childContext.ExecuteActivity(childContext.Activity);
}
else
{
eventActivitySubscriber.IsBlocked = true;
if (eventHandlers.IsScopeCompleted && AllHandlersAreQuiet(eventHandlers, context))
{
context.CloseActivity();
}
}
break;
}
}
break;
case ActivityExecutionStatus.Canceling:
case ActivityExecutionStatus.Faulting:
if (AllHandlersAreQuiet(eventHandlers, context))
{
context.CloseActivity();
}
break;
}
}
