private void NotifyChangesCompletedToChildExecutors(IWorkflowCoreRuntime workflowCoreRuntime, Activity contextActivity)
{
Queue compositeActivities = new Queue();
compositeActivities.Enqueue(contextActivity);
while (compositeActivities.Count > 0)
{
CompositeActivity compositeActivity = compositeActivities.Dequeue() as CompositeActivity;
if (compositeActivity == null || !WorkflowChanges.IsActivityExecutable(compositeActivity))
{
continue;
}
ISupportWorkflowChanges compositeActivityExecutor = ActivityExecutors.GetActivityExecutor(compositeActivity) as ISupportWorkflowChanges;
if (compositeActivityExecutor != null)
{
using (workflowCoreRuntime.SetCurrentActivity(compositeActivity))
{
using (ActivityExecutionContext executionContext = new ActivityExecutionContext(compositeActivity))
compositeActivityExecutor.OnWorkflowChangesCompleted(executionContext);
}
}
foreach (Activity activity in compositeActivity.Activities)
{
if (activity is CompositeActivity)
{
compositeActivities.Enqueue(activity);
}
}
}
}
private void NotifyChangesCompletedToChildExecutors(IWorkflowCoreRuntime workflowCoreRuntime, Activity contextActivity)
{
Queue queue = new Queue();
queue.Enqueue(contextActivity);
while (queue.Count > 0)
{
CompositeActivity activity = queue.Dequeue() as CompositeActivity;
if ((activity != null) && IsActivityExecutable(activity))
{
ISupportWorkflowChanges activityExecutor = ActivityExecutors.GetActivityExecutor(activity) as ISupportWorkflowChanges;
if (activityExecutor != null)
{
using (workflowCoreRuntime.SetCurrentActivity(activity))
{
using (ActivityExecutionContext context = new ActivityExecutionContext(activity))
{
activityExecutor.OnWorkflowChangesCompleted(context);
}
}
}
foreach (Activity activity2 in activity.Activities)
{
if (activity2 is CompositeActivity)
{
queue.Enqueue(activity2);
}
}
}
}
}
private void NotifyChangesToChildExecutors(IWorkflowCoreRuntime workflowCoreRuntime, Activity contextActivity, IList <WorkflowChangeAction> changeActions)
{
foreach (WorkflowChangeAction action in changeActions)
{
if (!(action is ActivityChangeAction))
{
continue;
}
CompositeActivity ownerActivity = contextActivity.TraverseDottedPathFromRoot(((ActivityChangeAction)action).OwnerActivityDottedPath) as CompositeActivity;
if (ownerActivity == null || !WorkflowChanges.IsActivityExecutable(ownerActivity))
{
continue;
}
ISupportWorkflowChanges compositeActivityExecutor = ActivityExecutors.GetActivityExecutor(ownerActivity) as ISupportWorkflowChanges;
if (compositeActivityExecutor == null)
{
throw new ApplicationException(SR.GetString(SR.Error_WorkflowChangesNotSupported, ownerActivity.GetType().FullName));
}
using (workflowCoreRuntime.SetCurrentActivity(ownerActivity))
{
using (ActivityExecutionContext executionContext = new ActivityExecutionContext(ownerActivity))
{
if (action is AddedActivityAction)
{
Activity addedActivity = ownerActivity.Activities[((AddedActivityAction)action).Index];
if (WorkflowChanges.IsActivityExecutable(addedActivity))
{
addedActivity.OnActivityExecutionContextLoad(executionContext.Activity.RootActivity.WorkflowCoreRuntime);
executionContext.InitializeActivity(addedActivity);
compositeActivityExecutor.OnActivityAdded(executionContext, addedActivity);
}
}
else if (action is RemovedActivityAction)
{
RemovedActivityAction removedActivityAction = (RemovedActivityAction)action;
if (WorkflowChanges.IsActivityExecutable(removedActivityAction.OriginalRemovedActivity))
{
compositeActivityExecutor.OnActivityRemoved(executionContext, removedActivityAction.OriginalRemovedActivity);
if (removedActivityAction.OriginalRemovedActivity.ExecutionResult != ActivityExecutionResult.Uninitialized)
{
removedActivityAction.OriginalRemovedActivity.Uninitialize(executionContext.Activity.RootActivity.WorkflowCoreRuntime);
removedActivityAction.OriginalRemovedActivity.SetValue(Activity.ExecutionResultProperty, ActivityExecutionResult.Uninitialized);
}
removedActivityAction.OriginalRemovedActivity.OnActivityExecutionContextUnload(executionContext.Activity.RootActivity.WorkflowCoreRuntime);
removedActivityAction.OriginalRemovedActivity.Dispose();
}
}
}
}
}
}
private void NotifyChangesToChildExecutors(IWorkflowCoreRuntime workflowCoreRuntime, Activity contextActivity, IList <WorkflowChangeAction> changeActions)
{
foreach (WorkflowChangeAction action in changeActions)
{
if (action is ActivityChangeAction)
{
CompositeActivity activity = contextActivity.TraverseDottedPathFromRoot(((ActivityChangeAction)action).OwnerActivityDottedPath) as CompositeActivity;
if ((activity != null) && IsActivityExecutable(activity))
{
ISupportWorkflowChanges activityExecutor = ActivityExecutors.GetActivityExecutor(activity) as ISupportWorkflowChanges;
if (activityExecutor == null)
{
throw new ApplicationException(SR.GetString("Error_WorkflowChangesNotSupported", new object[] { activity.GetType().FullName }));
}
using (workflowCoreRuntime.SetCurrentActivity(activity))
{
using (ActivityExecutionContext context = new ActivityExecutionContext(activity))
{
if (action is AddedActivityAction)
{
Activity activity2 = activity.Activities[((AddedActivityAction)action).Index];
if (IsActivityExecutable(activity2))
{
activity2.OnActivityExecutionContextLoad(context.Activity.RootActivity.WorkflowCoreRuntime);
context.InitializeActivity(activity2);
activityExecutor.OnActivityAdded(context, activity2);
}
}
else if (action is RemovedActivityAction)
{
RemovedActivityAction action2 = (RemovedActivityAction)action;
if (IsActivityExecutable(action2.OriginalRemovedActivity))
{
activityExecutor.OnActivityRemoved(context, action2.OriginalRemovedActivity);
if (action2.OriginalRemovedActivity.ExecutionResult != ActivityExecutionResult.Uninitialized)
{
action2.OriginalRemovedActivity.Uninitialize(context.Activity.RootActivity.WorkflowCoreRuntime);
action2.OriginalRemovedActivity.SetValue(Activity.ExecutionResultProperty, ActivityExecutionResult.Uninitialized);
}
action2.OriginalRemovedActivity.OnActivityExecutionContextUnload(context.Activity.RootActivity.WorkflowCoreRuntime);
action2.OriginalRemovedActivity.Dispose();
}
}
}
}
}
}
}
}
protected ActivityExecutor NextActivityExecutorInChain(Activity activity)
{
if (activity == null)
{
throw new ArgumentNullException("activity");
}
ActivityExecutor executor = null;
IList activityExecutors = ActivityExecutors.GetActivityExecutors(activity);
int index = activityExecutors.IndexOf(this);
if (index < (activityExecutors.Count - 1))
{
executor = (ActivityExecutor)activityExecutors[index + 1];
}
return(executor);
}
private static ActivityExecutionStatus ExecuteActivity(Activity activity, ActivityExecutionContext context, bool locksAcquired)
{
// acquire needed synchronization
TransactedContextFilter executor = (TransactedContextFilter)ActivityExecutors.GetActivityExecutorFromType(typeof(TransactedContextFilter));
if (!locksAcquired && !context.AcquireLocks(executor))
{
return(activity.ExecutionStatus);
}
// checkpoint for instance state
//
WorkflowTransactionOptions transaction = TransactedContextFilter.GetTransactionOptions(activity);
if (transaction != null)
{
context.CheckpointInstanceState();
}
// delegate to the next executor for the activity
return(executor.NextActivityExecutorInChain(activity).Execute(activity, context));
}
private static ActivityExecutionStatus ExecuteActivity(Activity activity, ActivityExecutionContext context, bool locksAcquired)
{
TransactedContextFilter activityExecutorFromType = (TransactedContextFilter)ActivityExecutors.GetActivityExecutorFromType(typeof(TransactedContextFilter));
if (!locksAcquired && !context.AcquireLocks(activityExecutorFromType))
{
return(activity.ExecutionStatus);
}
if (GetTransactionOptions(activity) != null)
{
context.CheckpointInstanceState();
}
return(activityExecutorFromType.NextActivityExecutorInChain(activity).Execute(activity, context));
}
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);
}
