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;
}
}
}
}
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 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);
}
}
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);
}
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
List <EventHandlerEventActivitySubscriber> eventActivitySubscribers = new List <EventHandlerEventActivitySubscriber>();
this.ActivityState = eventActivitySubscribers;
for (int i = 0; i < this.EnabledActivities.Count; ++i)
{
EventDrivenActivity childActivity = this.EnabledActivities[i] as EventDrivenActivity;
EventHandlerEventActivitySubscriber eventDrivenSubscriber = new EventHandlerEventActivitySubscriber(childActivity);
eventActivitySubscribers.Add(eventDrivenSubscriber);
childActivity.EventActivity.Subscribe(executionContext, eventDrivenSubscriber);
}
return(ActivityExecutionStatus.Executing);
}
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;
}
}
