public void SetWhenCondition(Activity activity, ActivityCondition handler)
{
if (activity.Parent is ConditionedActivityGroup)
{
activity.SetValue(ConditionedActivityGroup.WhenConditionProperty, handler);
}
}
protected override bool ApplyTo(Activity rootActivity)
{
if (rootActivity == null)
{
return false;
}
RuleDefinitions definitions = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (definitions == null)
{
definitions = new RuleDefinitions();
rootActivity.SetValue(RuleDefinitions.RuleDefinitionsProperty, definitions);
}
bool flag = false;
if (definitions.Conditions.RuntimeMode)
{
definitions.Conditions.RuntimeMode = false;
flag = true;
}
try
{
definitions.Conditions.Add(this.ConditionDefinition);
}
finally
{
if (flag)
{
definitions.Conditions.RuntimeMode = true;
}
}
return true;
}
private bool AcquireLocks(Activity activity)
{
// If this activity doesn't have any handles, we have nothing to do.
ICollection <string> handles = GetAllSynchronizationHandles(activity);
if (handles == null || handles.Count == 0)
{
return(true);
}
Activity parent = activity.Parent;
while (parent != null)
{
if (parent.SupportsSynchronization || parent.Parent == null)
{
Dictionary <string, GrantedLock> grantedLocks = (Dictionary <string, GrantedLock>)parent.GetValue(GrantedLocksProperty);
if (grantedLocks == null)
{
grantedLocks = new Dictionary <string, GrantedLock>();
parent.SetValue(GrantedLocksProperty, grantedLocks);
}
foreach (string handle in handles)
{
bool acquiredLocks = true;
if (!grantedLocks.ContainsKey(handle))
{
grantedLocks[handle] = new GrantedLock(activity);
}
else if (grantedLocks[handle].Holder != activity)
{
grantedLocks[handle].WaitList.Add(activity);
acquiredLocks = false;
}
if (!acquiredLocks)
{
return(false);
}
}
}
// If we reach a parent which has at least one handle, then we do not need to
// go any further as the parent would already have acquired all our locks for
// itself. Note that we still need to acquire our locks in the same parent if
// the parent ProvidesSychronization, hence, this if check is *not* after
// "parent = parent.Parent"!
ICollection <string> synchronizationHandlesOnParent = (ICollection <string>)parent.GetValue(Activity.SynchronizationHandlesProperty);
if (synchronizationHandlesOnParent != null && synchronizationHandlesOnParent.Count != 0)
{
break;
}
parent = parent.Parent;
}
return(true);
}
public void CheckpointInstanceState(System.Workflow.ComponentModel.Activity atomicActivity)
{
TransactionOptions transactionOptions = new TransactionOptions();
WorkflowTransactionOptions options2 = TransactedContextFilter.GetTransactionOptions(atomicActivity);
transactionOptions.IsolationLevel = options2.IsolationLevel;
if (transactionOptions.IsolationLevel == IsolationLevel.Unspecified)
{
transactionOptions.IsolationLevel = IsolationLevel.Serializable;
}
transactionOptions.Timeout = options2.TimeoutDuration;
TransactionalProperties properties = new TransactionalProperties();
atomicActivity.SetValue(WorkflowExecutor.TransactionalPropertiesProperty, properties);
this.ServiceProvider.CreateTransaction(transactionOptions);
this.currentAtomicActivity = atomicActivity;
this.scheduler.Pause();
}
private static Activity CloneRootActivity(Activity originalRootActivity)
{
string str = originalRootActivity.GetValue(Activity.WorkflowXamlMarkupProperty) as string;
string rulesMarkup = null;
Activity rootActivity = null;
IServiceProvider serviceProvider = originalRootActivity.GetValue(Activity.WorkflowRuntimeProperty) as IServiceProvider;
if (!string.IsNullOrEmpty(str))
{
rulesMarkup = originalRootActivity.GetValue(Activity.WorkflowRulesMarkupProperty) as string;
rootActivity = Activity.OnResolveActivityDefinition(null, str, rulesMarkup, true, false, serviceProvider);
}
else
{
rootActivity = Activity.OnResolveActivityDefinition(originalRootActivity.GetType(), null, null, true, false, serviceProvider);
}
if (rootActivity == null)
{
throw new NullReferenceException(SR.GetString("Error_InvalidRootForWorkflowChanges"));
}
ArrayList workflowChanges = (ArrayList)originalRootActivity.GetValue(WorkflowChangeActionsProperty);
if (workflowChanges != null)
{
workflowChanges = CloneWorkflowChangeActions(workflowChanges, originalRootActivity);
if (workflowChanges == null)
{
return(rootActivity);
}
foreach (WorkflowChangeAction action in workflowChanges)
{
action.ApplyTo(rootActivity);
}
rootActivity.SetValue(WorkflowChangeActionsProperty, workflowChanges);
}
return(rootActivity);
}
private void SerializeToMarkup(Activity workflow, string fileName)
{
workflow.SetValue(WorkflowMarkupSerializer.XClassProperty, null);
using (XmlWriter xmlWriter = XmlWriter.Create(fileName))
{
WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer();
markupSerializer.Serialize(xmlWriter, workflow);
}
RuleDefinitions ruleDefinitions = workflow.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (ruleDefinitions != null)
{
if (ruleDefinitions.Conditions.Count > 0 || ruleDefinitions.RuleSets.Count > 0)
{
String rulesFileName = GetRulesFileName(fileName);
using (XmlWriter xmlWriter = XmlWriter.Create(rulesFileName))
{
WorkflowMarkupSerializer markupSerializer = new WorkflowMarkupSerializer();
markupSerializer.Serialize(xmlWriter, ruleDefinitions);
}
}
}
}
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);
}
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;
}
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);
}
internal void ReleaseLocks(bool transactional)
{
if (this.currentActivity == null)
{
throw new ObjectDisposedException("ActivityExecutionContext");
}
// remove the callback.
this.Activity.RemoveProperty(LockAcquiredCallbackProperty);
// The assumption is that lock contentions will be few. Hence, we optimize serialization
// size over performance, for ex. do not persist the list of locks that have already been
// granted.
ICollection <string> handles = GetAllSynchronizationHandles(this.Activity);
if (handles == null || handles.Count == 0)
{
return;
}
List <Activity> waitingActivities = new List <Activity>();
Activity parent = Activity.Parent;
while (parent != null)
{
if (parent.SupportsSynchronization || parent.Parent == null)
{
Dictionary <string, GrantedLock> grantedLocks = (Dictionary <string, GrantedLock>)parent.GetValue(GrantedLocksProperty);
// if its an transactional release of locks, then release it and then keep it
// cached, so that in case of rollback, we can reacuire locks
if (transactional)
{
Dictionary <string, GrantedLock> cachedGrantedLocks = new Dictionary <string, GrantedLock>();
if (grantedLocks != null)
{
foreach (KeyValuePair <string, GrantedLock> grantedLockEntry in grantedLocks)
{
cachedGrantedLocks.Add(grantedLockEntry.Key, (GrantedLock)grantedLockEntry.Value.Clone());
}
}
parent.SetValue(CachedGrantedLocksProperty, cachedGrantedLocks);
}
if (grantedLocks != null)
{
foreach (string handle in handles)
{
if (!grantedLocks.ContainsKey(handle))
{
continue;
}
else if (grantedLocks[handle].WaitList.Count == 0)
{
grantedLocks.Remove(handle);
}
else if (grantedLocks[handle].Holder != this.Activity)
{
grantedLocks[handle].WaitList.Remove(this.Activity);
}
else
{
// Grant the lock to the next waiting activity.
Activity waitingActivity = grantedLocks[handle].WaitList[0];
grantedLocks[handle].WaitList.RemoveAt(0);
grantedLocks[handle].Holder = waitingActivity;
if (!waitingActivities.Contains(waitingActivity))
{
waitingActivities.Add(waitingActivity);
}
}
}
if (grantedLocks.Count == 0)
{
parent.RemoveProperty(GrantedLocksProperty);
}
}
}
// If we reach a parent which has at least one handle, then we do not need to
// go any further as the parent would already have acquired all our locks for
// itself. Note that we still need to acquire our locks in the same parent if
// the parent ProvidesSychronization, hence, this if check is *not* after
// "parent = parent.Parent"!
ICollection <string> synchronizationHandlesOnParent = (ICollection <string>)parent.GetValue(Activity.SynchronizationHandlesProperty);
if (synchronizationHandlesOnParent != null && synchronizationHandlesOnParent.Count != 0)
{
break;
}
parent = parent.Parent;
}
// Try and acquire locks for all the waiting activities.
foreach (Activity waitingActivity in waitingActivities)
{
if (AcquireLocks(waitingActivity))
{
ActivityExecutorDelegateInfo <EventArgs> waitingActivityCallback = (ActivityExecutorDelegateInfo <EventArgs>)waitingActivity.GetValue(LockAcquiredCallbackProperty);
waitingActivityCallback.InvokeDelegate(this.Activity.ContextActivity, EventArgs.Empty, false, transactional);
}
}
}
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);
}
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 void CheckpointInstanceState(Activity atomicActivity)
{
// Note that the WF4 runtime does not create checkpoints. If the transaction aborts, the workflow aborts.
// We are following the WF4 behavior and not creating a checkpoint.
TransactionOptions tranOpts = new TransactionOptions();
WorkflowTransactionOptions atomicTxn = TransactedContextFilter.GetTransactionOptions(atomicActivity);
tranOpts.IsolationLevel = atomicTxn.IsolationLevel;
if (tranOpts.IsolationLevel == IsolationLevel.Unspecified)
{
tranOpts.IsolationLevel = IsolationLevel.Serializable;
}
tranOpts.Timeout = atomicTxn.TimeoutDuration;
TransactionalProperties transactionProperties = new TransactionalProperties();
atomicActivity.SetValue(WorkflowExecutor.TransactionalPropertiesProperty, transactionProperties);
this.ServiceProvider.CreateTransaction(tranOpts);
this.currentAtomicActivity = atomicActivity;
this.scheduler.Pause();
}
internal static RuleDefinitions Load_Rules_RT(Activity declaringActivity)
{
RuleDefinitions ruleDefinitionsFromManifest = declaringActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (ruleDefinitionsFromManifest == null)
{
ruleDefinitionsFromManifest = GetRuleDefinitionsFromManifest(declaringActivity.GetType());
if (ruleDefinitionsFromManifest != null)
{
declaringActivity.SetValue(RuleDefinitions.RuleDefinitionsProperty, ruleDefinitionsFromManifest);
}
}
return ruleDefinitionsFromManifest;
}
internal static RuleDefinitions Load_Rules_RT(Activity declaringActivity)
{
RuleDefinitions rules = declaringActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
if (rules == null)
{
rules = ConditionHelper.GetRuleDefinitionsFromManifest(declaringActivity.GetType());
if (rules != null)
declaringActivity.SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
}
return rules;
}
private void CreateTransaction(Activity atomicActivity)
{
TransactionalProperties properties = new TransactionalProperties();
TransactionOptions options = new TransactionOptions();
WorkflowTransactionOptions transactionOptions = TransactedContextFilter.GetTransactionOptions(atomicActivity);
options.IsolationLevel = transactionOptions.IsolationLevel;
if (options.IsolationLevel == IsolationLevel.Unspecified)
{
options.IsolationLevel = IsolationLevel.Serializable;
}
options.Timeout = transactionOptions.TimeoutDuration;
CommittableTransaction transaction = new CommittableTransaction(options);
properties.Transaction = transaction;
WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, string.Concat(new object[] { "Workflow Runtime: WorkflowExecutor: instanceId: ", this.InstanceIdString, " .Created enlistable transaction ", transaction.GetHashCode(), " with timeout ", options.Timeout, ", isolation ", options.IsolationLevel }));
properties.LocalQueuingService = new WorkflowQueuingService(this.qService);
atomicActivity.SetValue(TransactionalPropertiesProperty, properties);
this.currentAtomicActivity = atomicActivity;
this.atomicActivityEvent = new ManualResetEvent(false);
WorkflowTrace.Runtime.TraceEvent(TraceEventType.Information, 0, "Workflow Runtime: WorkflowExecutor: instanceId: " + this.InstanceIdString + " .Set CurrentAtomicActivity to " + atomicActivity.Name);
}
public void SetWorkflowServiceAttributes(Activity activity, WorkflowServiceAttributes value)
{
activity.SetValue(ReceiveActivity.WorkflowServiceAttributesProperty, value);
}
internal static void ProcessDefTag(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, Activity activity, bool newSegment, string fileName)
{
ResourceManager manager = new ResourceManager("System.Workflow.ComponentModel.StringResources", typeof(ActivityBind).Assembly);
if (reader.NodeType == XmlNodeType.Attribute)
{
string str;
if (((str = reader.LocalName) != null) && (str == "Class"))
{
activity.SetValue(WorkflowMarkupSerializer.XClassProperty, reader.Value);
}
else
{
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LinePosition : 1));
}
}
else
{
bool flag = false;
bool isEmptyElement = reader.IsEmptyElement;
int depth = reader.Depth;
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
string localName = reader.LocalName;
if (localName != null)
{
if (localName == "Code")
{
if (isEmptyElement)
{
flag = true;
}
break;
}
bool flag1 = localName == "Constructor";
}
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LinePosition : 1));
return;
}
case XmlNodeType.Text:
case XmlNodeType.CDATA:
{
int num2 = (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LineNumber : 1;
int num3 = (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LinePosition : 1;
CodeSnippetTypeMember member = new CodeSnippetTypeMember(reader.Value) {
LinePragma = new CodeLinePragma(fileName, Math.Max(num2 - 1, 1))
};
member.UserData[UserDataKeys.CodeSegment_New] = newSegment;
member.UserData[UserDataKeys.CodeSegment_ColumnNumber] = (num3 + reader.Name.Length) - 1;
CodeTypeMemberCollection members = activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection;
if (members == null)
{
members = new CodeTypeMemberCollection();
activity.SetValue(WorkflowMarkupSerializer.XCodeProperty, members);
}
members.Add(member);
break;
}
case XmlNodeType.EndElement:
if (reader.Depth == depth)
{
flag = true;
}
break;
}
}
while (!flag && reader.Read());
}
}