protected internal override void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext)
{
SequenceHelper.OnWorkflowChangesCompleted(this, executionContext);
}
internal CompensationInfo(ActivityExecutionContext targetExecutionContext)
{
this.targetExecutionContext = targetExecutionContext;
}
protected override ActivityExecutionStatus Execute(T activity, ActivityExecutionContext executionContext)
{
return(base.Execute(activity, executionContext));
}
protected internal override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
return(SequenceHelper.Execute(this, executionContext));
}
private static bool TryCompensateLastCompletedChildActivity(ActivityExecutionContext context, Activity targetActivity, IActivityEventListener <ActivityExecutionStatusChangedEventArgs> statusChangeHandler, bool isimmediateCompensation)
{
SortedDictionary <int, CompensationInfo> sortedListOfCompensatableTargets = new SortedDictionary <int, CompensationInfo>();
if (!(targetActivity is CompositeActivity))
{
return(false);
}
//Walk through all of the direct children which are compensatable and add them in the sorted order of their completion
//bail out if any of the compensatable children is currently compensating/faulting or canceling
if (CollectCompensatableTargetActivities(targetActivity as CompositeActivity, sortedListOfCompensatableTargets, isimmediateCompensation))
{
return(true);
}
// walk through active contexts that contain compensatable child, add them in the sorted order of the completion
// this also, walks through the completed contexts which are compensatable and are nested directly within the active contexts and adds them in the order of their completion
// bail out if any activity is currently compensating/faulting or cancelling
if (CollectCompensatableActiveContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation))
{
return(true);
}
// walk through all completed execution contexts which are compensatable and are directly nested under the target activity,
//and add them to our sorted list
CollectCompensatableCompletedContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation);
//if there were no compensatable targets found, bail out
if (sortedListOfCompensatableTargets.Count == 0)
{
CompleteRevokedExecutionContext(targetActivity, context);
return(false);
}
int?lastCompletedOrderId = targetActivity.GetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty) as Nullable <int>;
int nextLastCompletedOrderId = -1;
//get the last compensatable target - this could be an activity, contextInfo or a Context
CompensationInfo lastCompensatableTarget = null;
foreach (int completedOrderId in sortedListOfCompensatableTargets.Keys)
{
if (lastCompletedOrderId.HasValue && lastCompletedOrderId < completedOrderId)
{
break;
}
lastCompensatableTarget = sortedListOfCompensatableTargets[completedOrderId];
nextLastCompletedOrderId = completedOrderId;
}
//We are done with compensation on entire branch, now complete execution contexts
//recursilvely which we might have opened up.
if (lastCompensatableTarget == null)
{
CompleteRevokedExecutionContext(targetActivity, context);
return(false);
}
targetActivity.SetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty, nextLastCompletedOrderId);
//the last compensatable target could be an activity
if (lastCompensatableTarget.TargetActivity != null && lastCompensatableTarget.TargetActivity is ICompensatableActivity)
{
lastCompensatableTarget.TargetActivity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
context.CompensateActivity(lastCompensatableTarget.TargetActivity);
return(true);
} //or get the last compensatable "completed" context
else if (lastCompensatableTarget.TargetExecutionInfo != null && lastCompensatableTarget.TargetExecutionContextManager != null)
{
ActivityExecutionContext revokedExecutionContext = lastCompensatableTarget.TargetExecutionContextManager.DiscardPersistedExecutionContext(lastCompensatableTarget.TargetExecutionInfo);
//get the "first" compensatable child and compensate it
if (revokedExecutionContext.Activity is ICompensatableActivity)
{
revokedExecutionContext.Activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
revokedExecutionContext.CompensateActivity(revokedExecutionContext.Activity);
return(true);
}
else if (revokedExecutionContext.Activity is CompositeActivity)
{
//get the last compensatable child of the revoked context
Activity compensatableChild = GetLastCompensatableChild(revokedExecutionContext.Activity as CompositeActivity);
if (compensatableChild != null)
{
compensatableChild.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
revokedExecutionContext.CompensateActivity(compensatableChild);
return(true);
}
else// recursively, walk the context tree and keep revoking the compensatable contexts
{
return(TryCompensateLastCompletedChildActivity(revokedExecutionContext, revokedExecutionContext.Activity, statusChangeHandler, false));
}
}
}
else if (lastCompensatableTarget.TargetExecutionContext != null) //or get the last compensatable "active" context
{
if (lastCompensatableTarget.TargetExecutionContext.Activity is CompositeActivity)
{
//get the last compensatable child of the active context
Activity compensatableChild = GetLastCompensatableChild(lastCompensatableTarget.TargetExecutionContext.Activity as CompositeActivity);
if (compensatableChild != null)
{
compensatableChild.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
lastCompensatableTarget.TargetExecutionContext.CompensateActivity(compensatableChild);
return(true);
}
else // recursively, walk the context tree and keep revoking the compensatable contexts
{
return(TryCompensateLastCompletedChildActivity(lastCompensatableTarget.TargetExecutionContext, lastCompensatableTarget.TargetExecutionContext.Activity, statusChangeHandler, false));
}
}
}
return(false);
}
private bool MayInvokeDelegateNow(Activity currentContextActivity)
{
if ((this.activityQualifiedName == null) || this.wantInTransact)
{
return(true);
}
if (!ActivityExecutionContext.IsInAtomicTransaction(currentContextActivity.WorkflowCoreRuntime.CurrentActivity))
{
return(true);
}
Activity contextActivityForId = currentContextActivity.WorkflowCoreRuntime.GetContextActivityForId(this.contextId);
if (contextActivityForId == null)
{
return(false);
}
Activity activityByName = contextActivityForId.GetActivityByName(this.activityQualifiedName, true);
if (activityByName == null)
{
return(false);
}
return((ActivityExecutionContext.IsInAtomicTransaction(activityByName) && ActivityExecutionContext.IsInAtomicTransaction(currentContextActivity.WorkflowCoreRuntime.CurrentActivity)) || activityByName.MetaEquals(currentContextActivity));
}
protected internal virtual ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext)
{
return(ActivityExecutionStatus.Canceling);
}
public ActivityExecutionContext CreateExecutionContext(Activity activity)
{
if (this.ownerContext == null)
{
throw new ObjectDisposedException("ActivityExecutionContextManager");
}
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (!this.ownerContext.IsValidChild(activity, true))
{
throw new ArgumentException(SR.GetString(SR.AEC_InvalidActivity), "activity");
}
Activity copiedActivity = activity.Clone();
((IDependencyObjectAccessor)copiedActivity).InitializeInstanceForRuntime(this.ownerContext.Activity.WorkflowCoreRuntime);
//Reset the cloned tree for execution.
Queue <Activity> activityQueue = new Queue <Activity>();
activityQueue.Enqueue(copiedActivity);
while (activityQueue.Count != 0)
{
Activity clonedActivity = activityQueue.Dequeue();
if (clonedActivity.ExecutionStatus != ActivityExecutionStatus.Initialized)
{
clonedActivity.ResetAllKnownDependencyProperties();
CompositeActivity compositeActivity = clonedActivity as CompositeActivity;
if (compositeActivity != null)
{
for (int i = 0; i < compositeActivity.EnabledActivities.Count; ++i)
{
activityQueue.Enqueue(compositeActivity.EnabledActivities[i]);
}
ISupportAlternateFlow alternateFlow = compositeActivity as ISupportAlternateFlow;
if (alternateFlow != null)
{
for (int i = 0; i < alternateFlow.AlternateFlowActivities.Count; ++i)
{
activityQueue.Enqueue(alternateFlow.AlternateFlowActivities[i]);
}
}
}
}
}
// get active context activities and add it to this one
IList <Activity> activeContexts = (IList <Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty);
if (activeContexts == null)
{
activeContexts = new List <Activity>();
this.ownerContext.Activity.ContextActivity.SetValue(Activity.ActiveExecutionContextsProperty, activeContexts);
}
activeContexts.Add(copiedActivity);
// prepare the copied activity as a context activity
ActivityExecutionContextInfo contextInfo = new ActivityExecutionContextInfo(activity.QualifiedName, this.ownerContext.WorkflowCoreRuntime.GetNewContextActivityId(), Guid.NewGuid(), this.ownerContext.ContextId);
copiedActivity.SetValue(Activity.ActivityExecutionContextInfoProperty, contextInfo);
copiedActivity.SetValue(Activity.ActivityContextGuidProperty, contextInfo.ContextGuid);
ActivityExecutionContext newExecutionContext = null;
try
{
// inform workflow runtime
this.ownerContext.Activity.WorkflowCoreRuntime.RegisterContextActivity(copiedActivity);
// return the new context
newExecutionContext = new ActivityExecutionContext(copiedActivity);
this.executionContexts.Add(newExecutionContext);
newExecutionContext.InitializeActivity(newExecutionContext.Activity);
return(newExecutionContext);
}
catch (Exception)
{
if (newExecutionContext != null)
{
this.CompleteExecutionContext(newExecutionContext);
}
else
{
activeContexts.Remove(copiedActivity);
}
throw;
}
}
protected internal virtual void OnActivityChangeRemove(ActivityExecutionContext executionContext, Activity removedActivity)
{
}
protected internal virtual void OnWorkflowChangesCompleted(ActivityExecutionContext rootContext)
{
}
private ActivityExecutionStatus CompensateTargetActivity(ActivityExecutionContext context)
{
Activity targetActivity = null;
Activity commonParentActivity = context.Activity;
do
{
commonParentActivity = commonParentActivity.Parent;
targetActivity = commonParentActivity.GetActivityByName(this.TargetActivityName, true);
} while (targetActivity == null);
if (targetActivity is ICompensatableActivity &&
targetActivity.ExecutionStatus == ActivityExecutionStatus.Closed &&
targetActivity.ExecutionResult == ActivityExecutionResult.Succeeded)
{
// same execution context
targetActivity.RegisterForStatusChange(Activity.ClosedEvent, this);
context.CompensateActivity(targetActivity);
return(context.Activity.ExecutionStatus);
}
else if (targetActivity.ExecutionStatus == ActivityExecutionStatus.Initialized)
{
// Template activity
// walk through active contexts
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
foreach (ActivityExecutionContext activeContext in contextManager.ExecutionContexts)
{
if (targetActivity.GetActivityByName(activeContext.Activity.QualifiedName, true) != null)
{
if (activeContext.Activity.ExecutionStatus == ActivityExecutionStatus.Compensating ||
activeContext.Activity.ExecutionStatus == ActivityExecutionStatus.Faulting ||
activeContext.Activity.ExecutionStatus == ActivityExecutionStatus.Canceling
)
{
return(context.Activity.ExecutionStatus);
}
}
}
// walk through all completed execution contexts
for (int index = contextManager.CompletedExecutionContexts.Count - 1; index >= 0; index--)
{
//only compensate direct child during explicit compensation
ActivityExecutionContextInfo completedActivityInfo = contextManager.CompletedExecutionContexts[index];
if (((completedActivityInfo.Flags & PersistFlags.NeedsCompensation) != 0))
{
ActivityExecutionContext revokedExecutionContext = contextManager.DiscardPersistedExecutionContext(completedActivityInfo);
if (revokedExecutionContext.Activity is ICompensatableActivity)
{
revokedExecutionContext.Activity.RegisterForStatusChange(Activity.ClosedEvent, this);
revokedExecutionContext.CompensateActivity(revokedExecutionContext.Activity);
}
return(context.Activity.ExecutionStatus);
}
}
}
else
{
// currently faulting, canceling, or compensating
if (CompensationUtils.TryCompensateLastCompletedChildActivity(context, targetActivity, this))
{
return(context.Activity.ExecutionStatus);
}
}
return(ActivityExecutionStatus.Closed);
}
public sealed override ActivityExecutionStatus HandleFault(Activity activity, ActivityExecutionContext executionContext, Exception exception)
{
return(this.HandleFault((T)activity, executionContext, exception));
}
public sealed override ActivityExecutionStatus Cancel(Activity activity, ActivityExecutionContext executionContext)
{
return(this.Cancel((T)activity, executionContext));
}
public sealed override ActivityExecutionStatus Compensate(Activity activity, ActivityExecutionContext executionContext)
{
return(this.Compensate((T)activity, executionContext));
}
protected internal virtual ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
needs_exec = false;
return(ActivityExecutionStatus.Closed);
}
public void CompleteExecutionContext(ActivityExecutionContext childContext, bool forcePersist)
{
if (this.ownerContext == null)
{
throw new ObjectDisposedException("ActivityExecutionContextManager");
}
if (childContext == null)
{
throw new ArgumentNullException("childContext");
}
if (childContext.Activity == null)
{
throw new ArgumentException("childContext", SR.GetString(SR.Error_MissingActivityProperty));
}
if (childContext.Activity.ContextActivity == null)
{
throw new ArgumentException("childContext", SR.GetString(SR.Error_MissingContextActivityProperty));
}
if (!this.executionContexts.Contains(childContext))
{
throw new ArgumentException();
}
if (childContext.Activity.ContextActivity.ExecutionStatus != ActivityExecutionStatus.Closed && childContext.Activity.ContextActivity.ExecutionStatus != ActivityExecutionStatus.Initialized)
{
throw new InvalidOperationException(SR.GetString(System.Globalization.CultureInfo.CurrentCulture, SR.Error_CannotCompleteContext));
}
// make sure that this is in the active contexts collections
ActivityExecutionContextInfo childContextInfo = childContext.Activity.ContextActivity.GetValue(Activity.ActivityExecutionContextInfoProperty) as ActivityExecutionContextInfo;
IList <Activity> activeContexts = (IList <Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty);
if (activeContexts == null || !activeContexts.Contains(childContext.Activity.ContextActivity))
{
throw new ArgumentException();
}
// add it to completed contexts collection
bool needsCompensation = childContext.Activity.NeedsCompensation;
if (needsCompensation || forcePersist)
{
// add it to completed contexts
List <ActivityExecutionContextInfo> completedContexts = this.ownerContext.Activity.ContextActivity.GetValue(Activity.CompletedExecutionContextsProperty) as List <ActivityExecutionContextInfo>;
if (completedContexts == null)
{
completedContexts = new List <ActivityExecutionContextInfo>();
this.ownerContext.Activity.ContextActivity.SetValue(Activity.CompletedExecutionContextsProperty, completedContexts);
}
if (needsCompensation)
{
childContextInfo.Flags = PersistFlags.NeedsCompensation;
}
if (forcePersist)
{
childContextInfo.Flags |= PersistFlags.ForcePersist;
}
childContextInfo.SetCompletedOrderId(this.ownerContext.Activity.IncrementCompletedOrderId());
completedContexts.Add(childContextInfo);
// ask runtime to save the context activity
this.ownerContext.Activity.WorkflowCoreRuntime.SaveContextActivity(childContext.Activity);
}
// remove it from active contexts
activeContexts.Remove(childContext.Activity.ContextActivity);
this.executionContexts.Remove(childContext);
//Case for those context which has compensatable child context, when those context
//are completed at the end of Compensation chain we need to uninitialize the context
//activity associated to them.
if (childContext.Activity.ContextActivity.CanUninitializeNow && childContext.Activity.ContextActivity.ExecutionResult != ActivityExecutionResult.Uninitialized)
{
childContext.Activity.ContextActivity.Uninitialize(this.ownerContext.Activity.RootActivity.WorkflowCoreRuntime);
childContext.Activity.ContextActivity.SetValue(Activity.ExecutionResultProperty, ActivityExecutionResult.Uninitialized);
}
// unregister it from runtime
this.ownerContext.Activity.WorkflowCoreRuntime.UnregisterContextActivity(childContext.Activity);
if (!(needsCompensation || forcePersist))
{
childContext.Activity.Dispose();
}
}
protected internal virtual ActivityExecutionStatus HandleFault(ActivityExecutionContext executionContext, Exception exception)
{
return(ActivityExecutionStatus.Closed);
}
internal StartWorkflow(ActivityExecutionContext executionContext)
{
this.executionContext = executionContext;
}
public ActivityExecutionStatus ExecuteInternal(ActivityExecutionContext executionContext)
{
return(Execute(executionContext));
}
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e)
{
ActivityExecutionContext context = sender as ActivityExecutionContext;
if (context == null)
{
throw new ArgumentException("sender");
}
if (e.Activity == context.Activity)
{
if (context.Activity.HasPrimaryClosed && !(bool)context.Activity.GetValue(CompensateProcessedProperty))
{
context.Activity.SetValue(CompensateProcessedProperty, true);
if (context.Activity.ExecutionResult == ActivityExecutionResult.Compensated)
{
// run compensation handler or do default compensation handling
Activity compensationHandler = GetCompensationHandler(context.Activity);
if (compensationHandler != null)
{
// subscribe for status change on compensation handler
compensationHandler.RegisterForStatusChange(Activity.ClosedEvent, this);
// execute compensation handler
context.ExecuteActivity(compensationHandler);
}
else
{
// do default compensation
if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this))
{
// let activity get into closed state
context.Activity.ReleaseLockOnStatusChange(this);
}
}
}
else
{
// let activity get into closed state
context.Activity.ReleaseLockOnStatusChange(this);
}
}
}
else if (e.Activity is CompensationHandlerActivity && e.ExecutionStatus == ActivityExecutionStatus.Closed)
{
// remove subscriber for status change on compensation handler
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
// release lock on the primary activity
context.Activity.ReleaseLockOnStatusChange(this);
}
else if (e.ExecutionStatus == ActivityExecutionStatus.Closed)
{
// remove subscriber for status change on compensated activity
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this))
{
// release lock on the primary activity
context.Activity.ReleaseLockOnStatusChange(this);
}
}
}
public void OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e)
{
ActivityExecutionContext context = sender as ActivityExecutionContext;
if (context == null)
{
throw new ArgumentException("sender");
}
// waiting for primary activity to close
if (e.Activity == context.Activity)
{
if (context.Activity.HasPrimaryClosed &&
!(bool)context.Activity.GetValue(FaultAndCancellationHandlingFilter.FaultProcessedProperty))
{
context.Activity.SetValue(FaultAndCancellationHandlingFilter.FaultProcessedProperty, true);
if (context.Activity.WasExecuting &&
context.Activity.ExecutionResult == ActivityExecutionResult.Faulted &&
context.Activity.GetValue(ActivityExecutionContext.CurrentExceptionProperty) != null)
{
// execute exceptionHandlers, iff activity has transitioned from Executing to Faulting.
CompositeActivity exceptionHandlersActivity = FaultAndCancellationHandlingFilter.GetFaultHandlers(context.Activity);
if (exceptionHandlersActivity != null)
{
// listen for FaultHandler status change events
exceptionHandlersActivity.RegisterForStatusChange(Activity.ClosedEvent, this);
// execute exception handlers
context.ExecuteActivity(exceptionHandlersActivity);
}
else
{
// compensate completed children
if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this))
{
SafeReleaseLockOnStatusChange(context); // no children to compensate...release lock on to the close status of the activity
}
}
}
else if (context.Activity.ExecutionResult == ActivityExecutionResult.Canceled)
{
// if primary activity is closed and outcome is canceled, then run the cancel handler
Activity cancelHandler = FaultAndCancellationHandlingFilter.GetCancellationHandler(context.Activity);
if (cancelHandler != null)
{
// execute the cancel handler
cancelHandler.RegisterForStatusChange(Activity.ClosedEvent, this);
context.ExecuteActivity(cancelHandler);
}
else
{
// run default compensation
if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this))
{
SafeReleaseLockOnStatusChange(context); // release lock on to the close status of the activity
}
}
}
else // release lock on to the close status of the activity
{
SafeReleaseLockOnStatusChange(context);
}
}
}
else if ((e.Activity is FaultHandlersActivity || e.Activity is CancellationHandlerActivity)
&&
(e.ExecutionStatus == ActivityExecutionStatus.Closed)
)
{
// remove subscriber
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
// fetch the exception , it would be null if it was handled
if (context.Activity.GetValue(ActivityExecutionContext.CurrentExceptionProperty) != null)
{
// the exception was not handled by exceptionHandlers.... do default exceptionHandling
// compesate completed children
if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this))
{
SafeReleaseLockOnStatusChange(context); // no children to compensate.Release lock on to the close status of the activity
}
}
else// the exception was handled by the exceptionHandlers. Release lock on to the close status of the parent activity
{
SafeReleaseLockOnStatusChange(context);
}
}
else if (e.ExecutionStatus == ActivityExecutionStatus.Closed)
{
// compensation of a child was in progress. // remove subscriber for this
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
// see if there are other children to be compensated
if (!CompensationUtils.TryCompensateLastCompletedChildActivity(context, context.Activity, this))
{
SafeReleaseLockOnStatusChange(context); // release lock on to the close status of the parent activity
}
}
}
ActivityExecutionStatus ICompensatableActivity.Compensate(ActivityExecutionContext executionContext)
{
return(ActivityExecutionStatus.Closed);
}
public ActivityExecutionContext CreateExecutionContext(Activity activity)
{
ActivityExecutionContext context2;
if (this.ownerContext == null)
{
throw new ObjectDisposedException("ActivityExecutionContextManager");
}
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (!this.ownerContext.IsValidChild(activity, true))
{
throw new ArgumentException(SR.GetString("AEC_InvalidActivity"), "activity");
}
Activity item = activity.Clone();
((IDependencyObjectAccessor)item).InitializeInstanceForRuntime(this.ownerContext.Activity.WorkflowCoreRuntime);
Queue <Activity> queue = new Queue <Activity>();
queue.Enqueue(item);
while (queue.Count != 0)
{
Activity activity3 = queue.Dequeue();
if (activity3.ExecutionStatus != ActivityExecutionStatus.Initialized)
{
activity3.ResetAllKnownDependencyProperties();
CompositeActivity activity4 = activity3 as CompositeActivity;
if (activity4 != null)
{
for (int i = 0; i < activity4.EnabledActivities.Count; i++)
{
queue.Enqueue(activity4.EnabledActivities[i]);
}
ISupportAlternateFlow flow = activity4;
if (flow != null)
{
for (int j = 0; j < flow.AlternateFlowActivities.Count; j++)
{
queue.Enqueue(flow.AlternateFlowActivities[j]);
}
}
}
}
}
IList <Activity> list = (IList <Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty);
if (list == null)
{
list = new List <Activity>();
this.ownerContext.Activity.ContextActivity.SetValue(Activity.ActiveExecutionContextsProperty, list);
}
list.Add(item);
ActivityExecutionContextInfo info = new ActivityExecutionContextInfo(activity.QualifiedName, this.ownerContext.WorkflowCoreRuntime.GetNewContextActivityId(), Guid.NewGuid(), this.ownerContext.ContextId);
item.SetValue(Activity.ActivityExecutionContextInfoProperty, info);
item.SetValue(Activity.ActivityContextGuidProperty, info.ContextGuid);
ActivityExecutionContext context = null;
try
{
this.ownerContext.Activity.WorkflowCoreRuntime.RegisterContextActivity(item);
context = new ActivityExecutionContext(item);
this.executionContexts.Add(context);
context.InitializeActivity(context.Activity);
context2 = context;
}
catch (Exception)
{
if (context != null)
{
this.CompleteExecutionContext(context);
}
else
{
list.Remove(item);
}
throw;
}
return(context2);
}
protected override ActivityExecutionStatus Cancel(T activity, ActivityExecutionContext executionContext)
{
return(base.Cancel(activity, executionContext));
}
public void CompleteExecutionContext(ActivityExecutionContext childContext, bool forcePersist)
{
if (this.ownerContext == null)
{
throw new ObjectDisposedException("ActivityExecutionContextManager");
}
if (childContext == null)
{
throw new ArgumentNullException("childContext");
}
if (childContext.Activity == null)
{
throw new ArgumentException("childContext", SR.GetString("Error_MissingActivityProperty"));
}
if (childContext.Activity.ContextActivity == null)
{
throw new ArgumentException("childContext", SR.GetString("Error_MissingContextActivityProperty"));
}
if (!this.executionContexts.Contains(childContext))
{
throw new ArgumentException();
}
if ((childContext.Activity.ContextActivity.ExecutionStatus != ActivityExecutionStatus.Closed) && (childContext.Activity.ContextActivity.ExecutionStatus != ActivityExecutionStatus.Initialized))
{
throw new InvalidOperationException(SR.GetString(CultureInfo.CurrentCulture, "Error_CannotCompleteContext"));
}
ActivityExecutionContextInfo item = childContext.Activity.ContextActivity.GetValue(Activity.ActivityExecutionContextInfoProperty) as ActivityExecutionContextInfo;
IList <Activity> list = (IList <Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty);
if ((list == null) || !list.Contains(childContext.Activity.ContextActivity))
{
throw new ArgumentException();
}
bool needsCompensation = childContext.Activity.NeedsCompensation;
if (needsCompensation || forcePersist)
{
List <ActivityExecutionContextInfo> list2 = this.ownerContext.Activity.ContextActivity.GetValue(Activity.CompletedExecutionContextsProperty) as List <ActivityExecutionContextInfo>;
if (list2 == null)
{
list2 = new List <ActivityExecutionContextInfo>();
this.ownerContext.Activity.ContextActivity.SetValue(Activity.CompletedExecutionContextsProperty, list2);
}
if (needsCompensation)
{
item.Flags = PersistFlags.NeedsCompensation;
}
if (forcePersist)
{
item.Flags = (PersistFlags)((byte)(item.Flags | PersistFlags.ForcePersist));
}
item.SetCompletedOrderId(this.ownerContext.Activity.IncrementCompletedOrderId());
list2.Add(item);
this.ownerContext.Activity.WorkflowCoreRuntime.SaveContextActivity(childContext.Activity);
}
list.Remove(childContext.Activity.ContextActivity);
this.executionContexts.Remove(childContext);
if (childContext.Activity.ContextActivity.CanUninitializeNow && (childContext.Activity.ContextActivity.ExecutionResult != ActivityExecutionResult.Uninitialized))
{
childContext.Activity.ContextActivity.Uninitialize(this.ownerContext.Activity.RootActivity.WorkflowCoreRuntime);
childContext.Activity.ContextActivity.SetValue(Activity.ExecutionResultProperty, ActivityExecutionResult.Uninitialized);
}
this.ownerContext.Activity.WorkflowCoreRuntime.UnregisterContextActivity(childContext.Activity);
if (!needsCompensation && !forcePersist)
{
childContext.Activity.Dispose();
}
}
protected internal override void OnActivityChangeRemove(ActivityExecutionContext executionContext, Activity removedActivity)
{
SequenceHelper.OnActivityChangeRemove(this, executionContext, removedActivity);
}
private void InvokeDelegate(Activity currentContextActivity, Activity targetContextActivity, T e, bool sync, bool transacted)
{
ActivityExecutorDelegateOperation delegateOperation = null;
if (this.delegateValue != null)
{
delegateOperation = new ActivityExecutorDelegateOperation(this.activityQualifiedName, this.delegateValue, e, this.ContextId);
}
else
{
delegateOperation = new ActivityExecutorDelegateOperation(this.activityQualifiedName, this.eventListener, e, this.ContextId);
}
bool mayInvokeDelegateNow = MayInvokeDelegateNow(currentContextActivity);
if (mayInvokeDelegateNow && sync)
{
Activity targetActivity = targetContextActivity.GetActivityByName(this.activityQualifiedName);
using (currentContextActivity.WorkflowCoreRuntime.SetCurrentActivity(targetActivity))
{
delegateOperation.SynchronousInvoke = true;
delegateOperation.Run(currentContextActivity.WorkflowCoreRuntime);
}
}
else
{
// If in atomic and subscriber not in same scope
// Queue it on the subscriber's baseExecutor
Activity targetActivity = targetContextActivity.GetActivityByName(this.activityQualifiedName);
currentContextActivity.WorkflowCoreRuntime.ScheduleItem(delegateOperation, ActivityExecutionContext.IsInAtomicTransaction(targetActivity), transacted, !mayInvokeDelegateNow);
}
}
private static bool TryCompensateLastCompletedChildActivity(ActivityExecutionContext context, Activity targetActivity, IActivityEventListener <ActivityExecutionStatusChangedEventArgs> statusChangeHandler, bool isimmediateCompensation)
{
SortedDictionary <int, CompensationInfo> sortedListOfCompensatableTargets = new SortedDictionary <int, CompensationInfo>();
if (targetActivity is CompositeActivity)
{
if (CollectCompensatableTargetActivities(targetActivity as CompositeActivity, sortedListOfCompensatableTargets, isimmediateCompensation))
{
return(true);
}
if (CollectCompensatableActiveContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation))
{
return(true);
}
CollectCompensatableCompletedContexts(context, targetActivity, sortedListOfCompensatableTargets, isimmediateCompensation);
if (sortedListOfCompensatableTargets.Count == 0)
{
CompleteRevokedExecutionContext(targetActivity, context);
return(false);
}
int?nullable = targetActivity.GetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty) as int?;
int num = -1;
CompensationInfo info = null;
foreach (int num2 in sortedListOfCompensatableTargets.Keys)
{
if (nullable.HasValue)
{
int?nullable2 = nullable;
int num3 = num2;
if ((nullable2.GetValueOrDefault() < num3) && nullable2.HasValue)
{
break;
}
}
info = sortedListOfCompensatableTargets[num2];
num = num2;
}
if (info == null)
{
CompleteRevokedExecutionContext(targetActivity, context);
return(false);
}
targetActivity.SetValue(CompensationHandlingFilter.LastCompensatedOrderIdProperty, num);
if ((info.TargetActivity != null) && (info.TargetActivity is ICompensatableActivity))
{
info.TargetActivity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
context.CompensateActivity(info.TargetActivity);
return(true);
}
if ((info.TargetExecutionInfo != null) && (info.TargetExecutionContextManager != null))
{
ActivityExecutionContext context2 = info.TargetExecutionContextManager.DiscardPersistedExecutionContext(info.TargetExecutionInfo);
if (context2.Activity is ICompensatableActivity)
{
context2.Activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
context2.CompensateActivity(context2.Activity);
return(true);
}
if (context2.Activity is CompositeActivity)
{
Activity lastCompensatableChild = GetLastCompensatableChild(context2.Activity as CompositeActivity);
if (lastCompensatableChild != null)
{
lastCompensatableChild.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
context2.CompensateActivity(lastCompensatableChild);
return(true);
}
return(TryCompensateLastCompletedChildActivity(context2, context2.Activity, statusChangeHandler, false));
}
}
else if ((info.TargetExecutionContext != null) && (info.TargetExecutionContext.Activity is CompositeActivity))
{
Activity activity = GetLastCompensatableChild(info.TargetExecutionContext.Activity as CompositeActivity);
if (activity != null)
{
activity.RegisterForStatusChange(Activity.StatusChangedEvent, statusChangeHandler);
info.TargetExecutionContext.CompensateActivity(activity);
return(true);
}
return(TryCompensateLastCompletedChildActivity(info.TargetExecutionContext, info.TargetExecutionContext.Activity, statusChangeHandler, false));
}
}
return(false);
}
public override bool Run(IWorkflowCoreRuntime workflowCoreRuntime)
{
// get context activity
Activity contextActivity = workflowCoreRuntime.GetContextActivityForId(this.ContextId);
// Work around for ActivityExecutionStatusChangedEventArgs
ActivityExecutionStatusChangedEventArgs activityStatusChangeEventArgs = this.args as ActivityExecutionStatusChangedEventArgs;
if (activityStatusChangeEventArgs != null)
{
activityStatusChangeEventArgs.BaseExecutor = workflowCoreRuntime;
if (activityStatusChangeEventArgs.Activity == null)
{
// status change for an activity that has been deleted dynamically since.
activityStatusChangeEventArgs.BaseExecutor = null;
return(false);
}
}
// get activity, if null, or if activity has already closed or just initialized, or if primary has closed and
// the target of the notification is not ActivityExecutionFilter, then
Activity activity = contextActivity.GetActivityByName(this.activityQualifiedName);
if (activity == null ||
((activity.ExecutionStatus == ActivityExecutionStatus.Closed || activity.ExecutionStatus == ActivityExecutionStatus.Initialized) && !this.synchronousInvoke) ||
(activity.HasPrimaryClosed && !(this.eventListener is ActivityExecutionFilter))
)
{
return(false);
}
// call the delegate
try
{
using (workflowCoreRuntime.SetCurrentActivity(activity))
{
using (ActivityExecutionContext activityExecutionContext = new ActivityExecutionContext(activity))
{
if (this.delegateValue != null)
{
this.delegateValue(activityExecutionContext, this.args);
}
else
{
this.eventListener.OnEvent(activityExecutionContext, this.args);
}
}
}
}
catch (Exception e)
{
if (activity != null)
{
System.Workflow.Runtime.WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Subscription handler of Activity {0} threw {1}", activity.QualifiedName, e.ToString());
}
else
{
System.Workflow.Runtime.WorkflowTrace.Runtime.TraceEvent(TraceEventType.Error, 1, "Subscription handler threw {0}", e.ToString());
}
throw;
}
finally
{
// Work around for activity status change Event Args
if (activityStatusChangeEventArgs != null)
{
activityStatusChangeEventArgs.BaseExecutor = null;
}
}
return(true);
}
public RuleExecution(RuleValidation validation, object thisObject, System.Workflow.ComponentModel.ActivityExecutionContext activityExecutionContext) : this(validation, thisObject)
{
this.activityExecutionContext = activityExecutionContext;
}
public abstract ActivityExecutionStatus HandleFault(Activity activity, ActivityExecutionContext executionContext, Exception exception);
