protected override void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
// find out the status of the cag
ConditionedActivityGroup currentActivity = executionContext.Activity as ConditionedActivityGroup;
// if CAG is executing... fire the conditions on the net result
if (currentActivity.ExecutionStatus == ActivityExecutionStatus.Executing)
{
// but hold on, a derived cag could be applying model changes before it
// "really" starts executing the activities. In that case it will evaluate
// the conditions later, at the appropriate time.
ConditionedActivityGroupStateInfo state = currentActivity.CAGState;
if ((state != null) && (!state.Testing))
{
// fire away... fire away... said the CAG
if (this.EvaluateConditions(currentActivity, executionContext))
{
// CAG until indicates we are done, so no children execute
this.Cleanup(currentActivity, executionContext);
}
else
{
// start any pending activity required
this.TriggerChildren(currentActivity, executionContext);
}
}
}
}
protected override void OnActivityChangeRemove(ActivityExecutionContext executionContext, Activity removedActivity)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (removedActivity == null)
{
throw new ArgumentNullException("removedActivity");
}
if (!removedActivity.Enabled)
{
return;
}
ConditionedActivityGroup cag = executionContext.Activity as ConditionedActivityGroup;
Debug.Assert(cag != null);
// find out the status of the cag
ConditionedActivityGroupStateInfo state = cag.CAGState;
if ((cag.ExecutionStatus == ActivityExecutionStatus.Executing) && (state != null))
{
state.ChildrenStats.Remove(removedActivity.QualifiedName);
}
}
protected override void OnActivityChangeAdd(ActivityExecutionContext executionContext, Activity addedActivity)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (addedActivity == null)
{
throw new ArgumentNullException("addedActivity");
}
if (!addedActivity.Enabled)
{
return;
}
ConditionedActivityGroup currentActivity = executionContext.Activity as ConditionedActivityGroup;
Debug.Assert(currentActivity != null);
ConditionedActivityGroupStateInfo state = currentActivity.CAGState;
if (currentActivity.ExecutionStatus == ActivityExecutionStatus.Executing && state != null)
{
Debug.Assert(currentActivity == addedActivity.Parent, "Attempting to add wrong activity to CAG");
state.ChildrenStats[addedActivity.QualifiedName] = new CAGChildStats();
}
}
internal bool Cleanup(ConditionedActivityGroup cag, ActivityExecutionContext context)
{
// the completion condition has fired, or we are canceling
// either way, we want to cleanup
ConditionedActivityGroupStateInfo state = cag.CAGState;
state.Completed = true;
// cancel any children currently running
bool childrenActive = false;
Dictionary <string, CAGChildStats> childrenStats = state.ChildrenStats;
foreach (Activity act in cag.EnabledActivities)
{
// reset any Pending Execution for all child activity
if (childrenStats[act.QualifiedName].State == CAGChildState.Pending)
{
childrenStats[act.QualifiedName].State = CAGChildState.Idle;
}
// find the run-time activity
ActivityExecutionContext childContext = GetChildExecutionContext(context, act, false);
if (childContext != null)
{
// child must be running somewhere
Activity activity = GetRuntimeInitializedActivity(context, act);
switch (activity.ExecutionStatus)
{
case ActivityExecutionStatus.Executing:
// schedule cancellation on child
childContext.CancelActivity(activity);
childrenActive = true;
break;
case ActivityExecutionStatus.Canceling:
case ActivityExecutionStatus.Faulting:
childrenActive = true;
break;
case ActivityExecutionStatus.Closed:
CleanupChildAtClosure(context, activity);
break;
default:
// unhook our handler
// others will be removed when we get the complete/cancel notification
act.UnregisterForStatusChange(Activity.ClosedEvent, this);
break;
}
}
}
// if the CAG is quiet, we are all done
if (!childrenActive)
{
context.CloseActivity();
}
return(!childrenActive);
}
internal bool Cleanup(ConditionedActivityGroup cag, ActivityExecutionContext context)
{
ConditionedActivityGroupStateInfo cAGState = cag.CAGState;
cAGState.Completed = true;
bool flag = false;
Dictionary <string, CAGChildStats> childrenStats = cAGState.ChildrenStats;
foreach (Activity activity in cag.EnabledActivities)
{
if (childrenStats[activity.QualifiedName].State == CAGChildState.Pending)
{
childrenStats[activity.QualifiedName].State = CAGChildState.Idle;
}
ActivityExecutionContext context2 = GetChildExecutionContext(context, activity, false);
if (context2 != null)
{
Activity runtimeInitializedActivity = this.GetRuntimeInitializedActivity(context, activity);
switch (runtimeInitializedActivity.ExecutionStatus)
{
case ActivityExecutionStatus.Executing:
{
context2.CancelActivity(runtimeInitializedActivity);
flag = true;
continue;
}
case ActivityExecutionStatus.Canceling:
case ActivityExecutionStatus.Faulting:
{
flag = true;
continue;
}
case ActivityExecutionStatus.Closed:
{
this.CleanupChildAtClosure(context, runtimeInitializedActivity);
continue;
}
}
activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
}
}
if (!flag)
{
context.CloseActivity();
}
return(!flag);
}
private bool EvaluateChildConditions(ConditionedActivityGroup cag, Activity child, ActivityExecutionContext context)
{
bool flag;
ConditionedActivityGroupStateInfo cAGState = cag.CAGState;
try
{
cAGState.Testing = true;
ActivityCondition condition = (ActivityCondition)child.GetValue(WhenConditionProperty);
flag = (condition != null) ? condition.Evaluate(child, context) : (cAGState.ChildrenStats[child.QualifiedName].ExecutedCount == 0);
}
finally
{
cAGState.Testing = false;
}
return(flag);
}
public int GetChildActivityExecutedCount(Activity child)
{
if (child == null)
{
throw new ArgumentNullException("child");
}
ConditionedActivityGroupStateInfo cAGState = this.CAGState;
if (cAGState == null)
{
throw new InvalidOperationException(SR.GetString("Error_CAGNotExecuting", new object[] { base.QualifiedName }));
}
if (!cAGState.ChildrenStats.ContainsKey(child.QualifiedName))
{
throw new ArgumentException(SR.GetString("Error_CAGChildNotFound", new object[] { child.QualifiedName, base.QualifiedName }), "child");
}
return(cAGState.ChildrenStats[child.QualifiedName].ExecutedCount);
}
protected override void OnActivityChangeRemove(ActivityExecutionContext executionContext, Activity removedActivity)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (removedActivity == null)
{
throw new ArgumentNullException("removedActivity");
}
if (removedActivity.Enabled)
{
ConditionedActivityGroup activity = executionContext.Activity as ConditionedActivityGroup;
ConditionedActivityGroupStateInfo cAGState = activity.CAGState;
if ((activity.ExecutionStatus == ActivityExecutionStatus.Executing) && (cAGState != null))
{
cAGState.ChildrenStats.Remove(removedActivity.QualifiedName);
}
}
}
/// <summary>
/// Evaluate the While condition for a particular child of the CAG
/// If no While condition, it becomes "execute once"
/// </summary>
/// <param name="cag"></param>
/// <param name="child"></param>
/// <param name="context"></param>
/// <returns></returns>
private bool EvaluateChildConditions(ConditionedActivityGroup cag, Activity child, ActivityExecutionContext context)
{
#if LOG
Log("EvaluateChildConditions on activity " + child.QualifiedName + " inside " + cag.QualifiedName);
#endif
// determine the result of the when condition (evaluate once if not specified)
ConditionedActivityGroupStateInfo state = cag.CAGState;
try
{
state.Testing = true;
ActivityCondition whenCondition = (ActivityCondition)child.GetValue(ConditionedActivityGroup.WhenConditionProperty);
return((whenCondition != null)
? whenCondition.Evaluate(child, context)
: (state.ChildrenStats[child.QualifiedName].ExecutedCount == 0));
}
finally
{
state.Testing = false;
}
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
#if LOG
Log("Execute on " + this.QualifiedName);
#endif
// go figure out what the CAG needs to do
this.CAGState = new ConditionedActivityGroupStateInfo(this);
if (EvaluateConditions(this, executionContext))
{
// CAG until indicates we are done, so no children execute
return(ActivityExecutionStatus.Closed);
}
// start any pending activity required
TriggerChildren(this, executionContext);
return(this.ExecutionStatus);
}
public int GetChildActivityExecutedCount(Activity child)
{
if (child == null)
{
throw new ArgumentNullException("child");
}
ConditionedActivityGroupStateInfo conditionedInfo = this.CAGState;
if (conditionedInfo == null)
{
throw new InvalidOperationException(SR.GetString(SR.Error_CAGNotExecuting, this.QualifiedName));
}
if (!conditionedInfo.ChildrenStats.ContainsKey(child.QualifiedName))
{
throw new ArgumentException(SR.GetString(SR.Error_CAGChildNotFound, child.QualifiedName, this.QualifiedName), "child");
}
else
{
return(conditionedInfo.ChildrenStats[child.QualifiedName].ExecutedCount);
}
}
protected override void OnWorkflowChangesCompleted(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
ConditionedActivityGroup activity = executionContext.Activity as ConditionedActivityGroup;
if (activity.ExecutionStatus == ActivityExecutionStatus.Executing)
{
ConditionedActivityGroupStateInfo cAGState = activity.CAGState;
if ((cAGState != null) && !cAGState.Testing)
{
if (this.EvaluateConditions(activity, executionContext))
{
this.Cleanup(activity, executionContext);
}
else
{
this.TriggerChildren(activity, executionContext);
}
}
}
}
