public ActivityExecutionContext GetExecutionContext(Activity activity)
{
if (this.ownerContext == null)
{
throw new ObjectDisposedException("ActivityExecutionContextManager");
}
if (activity == null)
{
throw new ArgumentNullException("activity");
}
ActivityExecutionContextInfo info = activity.GetValue(Activity.ActivityExecutionContextInfoProperty) as ActivityExecutionContextInfo;
foreach (ActivityExecutionContext context in this.ExecutionContexts)
{
if (info == null)
{
if (context.Activity.ContextActivity.QualifiedName == activity.QualifiedName)
{
return(context);
}
}
else if (context.ContextGuid.Equals(info.ContextGuid))
{
return(context);
}
}
return(null);
}
public ActivityExecutionContext GetExecutionContext(Activity activity)
{
if (this.ownerContext == null)
{
throw new ObjectDisposedException("ActivityExecutionContextManager");
}
if (activity == null)
{
throw new ArgumentNullException("activity");
}
ActivityExecutionContextInfo contextInfo = activity.GetValue(Activity.ActivityExecutionContextInfoProperty) as ActivityExecutionContextInfo;
// Returns the first context for an activity with the same qualified name.
foreach (ActivityExecutionContext context in ExecutionContexts)
{
if (contextInfo == null) //Template being passed.
{
if (context.Activity.ContextActivity.QualifiedName == activity.QualifiedName)
{
return(context);
}
}
else //Context Sensitive Activity
{
if (context.ContextGuid.Equals(contextInfo.ContextGuid))
{
return(context);
}
}
}
return(null);
}
internal ActivityExecutionContext DiscardPersistedExecutionContext(ActivityExecutionContextInfo contextInfo)
{
if (contextInfo == null)
{
throw new ArgumentNullException("contextInfo");
}
IList <ActivityExecutionContextInfo> list = this.ownerContext.Activity.ContextActivity.GetValue(Activity.CompletedExecutionContextsProperty) as IList <ActivityExecutionContextInfo>;
if ((list == null) || !list.Contains(contextInfo))
{
throw new ArgumentException();
}
Activity item = this.ownerContext.WorkflowCoreRuntime.LoadContextActivity(contextInfo, this.ownerContext.Activity.ContextActivity.GetActivityByName(contextInfo.ActivityQualifiedName));
((IDependencyObjectAccessor)item).InitializeInstanceForRuntime(this.ownerContext.Activity.WorkflowCoreRuntime);
IList <Activity> list2 = (IList <Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty);
if (list2 == null)
{
list2 = new List <Activity>();
this.ownerContext.Activity.ContextActivity.SetValue(Activity.ActiveExecutionContextsProperty, list2);
}
list2.Add(item);
this.ownerContext.Activity.WorkflowCoreRuntime.RegisterContextActivity(item);
ActivityExecutionContext context = new ActivityExecutionContext(item);
this.executionContexts.Add(context);
WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "Revoking context {0}:{1}", new object[] { context.ContextId, context.Activity.ContextActivity.QualifiedName });
list.Remove(contextInfo);
return(context);
}
public ActivityExecutionContext GetPersistedExecutionContext(Guid contextGuid)
{
if (this.ownerContext == null)
{
throw new ObjectDisposedException("ActivityExecutionContextManager");
}
IList <ActivityExecutionContextInfo> list = this.ownerContext.Activity.ContextActivity.GetValue(Activity.CompletedExecutionContextsProperty) as IList <ActivityExecutionContextInfo>;
if (list == null)
{
throw new ArgumentException();
}
ActivityExecutionContextInfo contextInfo = null;
foreach (ActivityExecutionContextInfo info2 in list)
{
if ((info2.ContextGuid == contextGuid) && (((byte)(info2.Flags & PersistFlags.ForcePersist)) != 0))
{
contextInfo = info2;
break;
}
}
if (contextInfo == null)
{
throw new ArgumentException();
}
contextInfo.Flags = (PersistFlags)((byte)(((int)contextInfo.Flags) & 0xfd));
return(this.DiscardPersistedExecutionContext(contextInfo));
}
public override bool Equals(object obj)
{
ActivityExecutionContextInfo otherContextInfo = obj as ActivityExecutionContextInfo;
if (otherContextInfo != null)
{
return(this.ContextGuid.Equals(otherContextInfo.ContextGuid));
}
return(false);
}
private ActivityExecutionStatus CompensateTargetActivity(ActivityExecutionContext context)
{
Activity activityByName = null;
Activity activity2 = context.Activity;
do
{
activityByName = activity2.Parent.GetActivityByName(this.TargetActivityName, true);
}while (activityByName == null);
if (((activityByName is ICompensatableActivity) && (activityByName.ExecutionStatus == ActivityExecutionStatus.Closed)) && (activityByName.ExecutionResult == ActivityExecutionResult.Succeeded))
{
activityByName.RegisterForStatusChange(Activity.ClosedEvent, this);
context.CompensateActivity(activityByName);
return(context.Activity.ExecutionStatus);
}
if (activityByName.ExecutionStatus == ActivityExecutionStatus.Initialized)
{
ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
foreach (ActivityExecutionContext context2 in executionContextManager.ExecutionContexts)
{
if ((activityByName.GetActivityByName(context2.Activity.QualifiedName, true) != null) && (((context2.Activity.ExecutionStatus == ActivityExecutionStatus.Compensating) || (context2.Activity.ExecutionStatus == ActivityExecutionStatus.Faulting)) || (context2.Activity.ExecutionStatus == ActivityExecutionStatus.Canceling)))
{
return(context.Activity.ExecutionStatus);
}
}
for (int i = executionContextManager.CompletedExecutionContexts.Count - 1; i >= 0; i--)
{
ActivityExecutionContextInfo contextInfo = executionContextManager.CompletedExecutionContexts[i];
if (((byte)(contextInfo.Flags & PersistFlags.NeedsCompensation)) != 0)
{
ActivityExecutionContext context3 = executionContextManager.DiscardPersistedExecutionContext(contextInfo);
if (context3.Activity is ICompensatableActivity)
{
context3.Activity.RegisterForStatusChange(Activity.ClosedEvent, this);
context3.CompensateActivity(context3.Activity);
}
return(context.Activity.ExecutionStatus);
}
}
}
else if (CompensationUtils.TryCompensateLastCompletedChildActivity(context, activityByName, this))
{
return(context.Activity.ExecutionStatus);
}
return(ActivityExecutionStatus.Closed);
}
private static void CollectCompensatableCompletedContexts(ActivityExecutionContext context, Activity targetActivity, SortedDictionary <int, CompensationInfo> sortedListOfCompensatableTargets, bool immediateCompensation)
{
ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
for (int i = executionContextManager.CompletedExecutionContexts.Count - 1; i >= 0; i--)
{
ActivityExecutionContextInfo targetExecutionInfo = executionContextManager.CompletedExecutionContexts[i];
if (((byte)(targetExecutionInfo.Flags & PersistFlags.NeedsCompensation)) != 0)
{
Activity activityByName = targetActivity.GetActivityByName(targetExecutionInfo.ActivityQualifiedName, true);
if ((activityByName != null) && (!immediateCompensation || !IsActivityInBackWorkBranch(targetActivity, activityByName)))
{
sortedListOfCompensatableTargets.Add(targetExecutionInfo.CompletedOrderId, new CompensationInfo(targetExecutionInfo, executionContextManager));
}
}
}
}
internal ActivityExecutionContext DiscardPersistedExecutionContext(ActivityExecutionContextInfo contextInfo)
{
if (contextInfo == null)
{
throw new ArgumentNullException("contextInfo");
}
// check if child execution context
IList <ActivityExecutionContextInfo> completedContexts = this.ownerContext.Activity.ContextActivity.GetValue(Activity.CompletedExecutionContextsProperty) as IList <ActivityExecutionContextInfo>;
if (completedContexts == null || !completedContexts.Contains(contextInfo))
{
throw new ArgumentException();
}
// revoke from persistence service
Activity revokedActivity = this.ownerContext.WorkflowCoreRuntime.LoadContextActivity(contextInfo, this.ownerContext.Activity.ContextActivity.GetActivityByName(contextInfo.ActivityQualifiedName));
((IDependencyObjectAccessor)revokedActivity).InitializeInstanceForRuntime(this.ownerContext.Activity.WorkflowCoreRuntime);
// add it back to active contexts
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(revokedActivity);
// inform workflow runtime
this.ownerContext.Activity.WorkflowCoreRuntime.RegisterContextActivity(revokedActivity);
// return the new context
ActivityExecutionContext revokedContext = new ActivityExecutionContext(revokedActivity);
this.executionContexts.Add(revokedContext);
System.Workflow.Runtime.WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "Revoking context {0}:{1}", revokedContext.ContextId, revokedContext.Activity.ContextActivity.QualifiedName);
// remove it from completed contexts
completedContexts.Remove(contextInfo);
return(revokedContext);
}
// walk through all completed execution contexts which are compensatable and are directly nested under the target activity,
//and add them to our sorted list
private static void CollectCompensatableCompletedContexts(ActivityExecutionContext context, Activity targetActivity, SortedDictionary <int, CompensationInfo> sortedListOfCompensatableTargets, bool immediateCompensation)
{
// walk through all completed execution contexts, add them to our sorted list
ActivityExecutionContextManager contextManager = context.ExecutionContextManager;
for (int index = contextManager.CompletedExecutionContexts.Count - 1; index >= 0; index--)
{
//if the context does not have any compensatable children, continue
ActivityExecutionContextInfo completedActivityInfo = contextManager.CompletedExecutionContexts[index];
if ((completedActivityInfo.Flags & PersistFlags.NeedsCompensation) == 0)
{
continue;
}
//ok, found a compensatable child.
Activity completedActivity = targetActivity.GetActivityByName(completedActivityInfo.ActivityQualifiedName, true);
if (completedActivity != null && !(immediateCompensation && IsActivityInBackWorkBranch(targetActivity, completedActivity)))
{
sortedListOfCompensatableTargets.Add(completedActivityInfo.CompletedOrderId, new CompensationInfo(completedActivityInfo, contextManager));
}
}
}
public ActivityExecutionContext GetPersistedExecutionContext(Guid contextGuid)
{
if (this.ownerContext == null)
{
throw new ObjectDisposedException("ActivityExecutionContextManager");
}
// Check if child execution context exists.
IList <ActivityExecutionContextInfo> completedContexts = this.ownerContext.Activity.ContextActivity.GetValue(Activity.CompletedExecutionContextsProperty) as IList <ActivityExecutionContextInfo>;
if (completedContexts == null)
{
throw new ArgumentException();
}
ActivityExecutionContextInfo contextInfo = null;
foreach (ActivityExecutionContextInfo completedContextInfo in completedContexts)
{
if (completedContextInfo.ContextGuid == contextGuid && ((completedContextInfo.Flags & PersistFlags.ForcePersist) != 0))
{
contextInfo = completedContextInfo;
break;
}
}
if (contextInfo == null)
{
throw new ArgumentException();
}
// The caller would have to close the AEC with forcepersist the next time
// around.
contextInfo.Flags &= ~PersistFlags.ForcePersist;
return(DiscardPersistedExecutionContext(contextInfo));
}
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;
}
}
public Activity LoadContextActivity(ActivityExecutionContextInfo contextInfo, Activity outerContextActivity)
{
throw new NotImplementedException(string.Format(CultureInfo.CurrentCulture, ExecutionStringManager.InteropNonSupportedBehavior, this.ServiceProvider.Activity.DisplayName));
}
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);
}
internal ActivityExecutionContext DiscardPersistedExecutionContext(ActivityExecutionContextInfo contextInfo)
{
if (contextInfo == null)
{
throw new ArgumentNullException("contextInfo");
}
IList<ActivityExecutionContextInfo> list = this.ownerContext.Activity.ContextActivity.GetValue(Activity.CompletedExecutionContextsProperty) as IList<ActivityExecutionContextInfo>;
if ((list == null) || !list.Contains(contextInfo))
{
throw new ArgumentException();
}
Activity item = this.ownerContext.WorkflowCoreRuntime.LoadContextActivity(contextInfo, this.ownerContext.Activity.ContextActivity.GetActivityByName(contextInfo.ActivityQualifiedName));
((IDependencyObjectAccessor) item).InitializeInstanceForRuntime(this.ownerContext.Activity.WorkflowCoreRuntime);
IList<Activity> list2 = (IList<Activity>) this.ownerContext.Activity.ContextActivity.GetValue(Activity.ActiveExecutionContextsProperty);
if (list2 == null)
{
list2 = new List<Activity>();
this.ownerContext.Activity.ContextActivity.SetValue(Activity.ActiveExecutionContextsProperty, list2);
}
list2.Add(item);
this.ownerContext.Activity.WorkflowCoreRuntime.RegisterContextActivity(item);
ActivityExecutionContext context = new ActivityExecutionContext(item);
this.executionContexts.Add(context);
WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "Revoking context {0}:{1}", new object[] { context.ContextId, context.Activity.ContextActivity.QualifiedName });
list.Remove(contextInfo);
return context;
}
internal ActivityExecutionContext DiscardPersistedExecutionContext(ActivityExecutionContextInfo contextInfo)
{
if (contextInfo == null)
throw new ArgumentNullException("contextInfo");
// check if child execution context
IList<ActivityExecutionContextInfo> completedContexts = this.ownerContext.Activity.ContextActivity.GetValue(Activity.CompletedExecutionContextsProperty) as IList<ActivityExecutionContextInfo>;
if (completedContexts == null || !completedContexts.Contains(contextInfo))
throw new ArgumentException();
// revoke from persistence service
Activity revokedActivity = this.ownerContext.WorkflowCoreRuntime.LoadContextActivity(contextInfo, this.ownerContext.Activity.ContextActivity.GetActivityByName(contextInfo.ActivityQualifiedName));
((IDependencyObjectAccessor)revokedActivity).InitializeInstanceForRuntime(this.ownerContext.Activity.WorkflowCoreRuntime);
// add it back to active contexts
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(revokedActivity);
// inform workflow runtime
this.ownerContext.Activity.WorkflowCoreRuntime.RegisterContextActivity(revokedActivity);
// return the new context
ActivityExecutionContext revokedContext = new ActivityExecutionContext(revokedActivity);
this.executionContexts.Add(revokedContext);
System.Workflow.Runtime.WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "Revoking context {0}:{1}", revokedContext.ContextId, revokedContext.Activity.ContextActivity.QualifiedName);
// remove it from completed contexts
completedContexts.Remove(contextInfo);
return revokedContext;
}
internal CompensationInfo(ActivityExecutionContextInfo targetExecutionInfo, ActivityExecutionContextManager targetExecutionContextManager)
{
this.targetExecutionInfo = targetExecutionInfo;
this.targetExecutionContextManager = targetExecutionContextManager;
}
public override bool Equals(object obj)
{
ActivityExecutionContextInfo info = obj as ActivityExecutionContextInfo;
return((info != null) && this.ContextGuid.Equals(info.ContextGuid));
}
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);
}
internal CompensationInfo(ActivityExecutionContextInfo targetExecutionInfo, ActivityExecutionContextManager targetExecutionContextManager)
{
this.targetExecutionInfo = targetExecutionInfo;
this.targetExecutionContextManager = targetExecutionContextManager;
}
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();
}
}
Activity IWorkflowCoreRuntime.LoadContextActivity(ActivityExecutionContextInfo contextInfo, Activity outerActivity)
{
if (!ServiceEnvironment.IsInServiceThread(this.InstanceId))
throw new InvalidOperationException(ExecutionStringManager.MustUseRuntimeThread);
Activity contextActivity = null;
if (this.completedContextActivities.Contains(contextInfo))
{
contextActivity = (Activity)this.completedContextActivities[contextInfo];
this.completedContextActivities.Remove(contextInfo);
if (contextActivity.Parent != outerActivity.Parent)
contextActivity.parent = outerActivity.Parent;
}
else
{
using (RuntimeEnvironment runtimeEnv = new RuntimeEnvironment(this.WorkflowRuntime))
{
contextActivity = this.WorkflowRuntime.WorkflowPersistenceService.LoadCompletedContextActivity(contextInfo.ContextGuid, outerActivity);
if (contextActivity == null)
throw new InvalidOperationException(ExecutionStringManager.LoadContextActivityFailed);
}
}
return contextActivity;
}
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();
}
}
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;
}
}
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;
}
