static void AddTransitionData(NativeActivityMetadata metadata, InternalTransition internalTransition, Transition transition)
{
TransitionData transitionData = new TransitionData();
Activity<bool> condition = transition.Condition;
transitionData.Condition = condition;
if (condition != null)
{
metadata.AddChild(condition);
}
Activity action = transition.Action;
transitionData.Action = action;
if (action != null)
{
metadata.AddChild(action);
}
if (transition.To != null)
{
transitionData.To = transition.To.InternalState;
}
internalTransition.TransitionDataList.Add(transitionData);
}
void ProcessTransitions(NativeActivityMetadata metadata)
{
for (int i = 0; i < this.Transitions.Count; i++)
{
Transition transition = this.Transitions[i];
InternalTransition internalTransition = null;
Activity triggerActivity = transition.ActiveTrigger;
if (!this.triggerInternalTransitionMapping.TryGetValue(triggerActivity, out internalTransition))
{
metadata.AddChild(triggerActivity);
internalTransition = new InternalTransition
{
Trigger = triggerActivity,
InternalTransitionIndex = this.internalTransitions.Count,
};
this.triggerInternalTransitionMapping.Add(triggerActivity, internalTransition);
this.internalTransitions.Add(internalTransition);
}
AddTransitionData(metadata, internalTransition, transition);
}
}
void OnConditionComplete(NativeActivityContext context, ActivityInstance completedInstance, bool result)
{
StateMachineEventManager eventManager = this.EventManager.Get(context);
int triggerId = eventManager.CurrentBeingProcessedEvent.TriggedId;
if (result)
{
this.TakeTransition(context, eventManager, triggerId);
}
else
{
// condition failed: reschedule trigger
int currentConditionIndex = eventManager.CurrentConditionIndex;
Fx.Assert(eventManager.CurrentConditionIndex >= 0, "Conditional Transition must have non-negative index.");
InternalTransition transition = this.GetInternalTransition(triggerId);
currentConditionIndex++;
if (currentConditionIndex < transition.TransitionDataList.Count)
{
eventManager.CurrentConditionIndex = currentConditionIndex;
context.ScheduleActivity<bool>(transition.TransitionDataList[currentConditionIndex].Condition, this.onConditionComplete, null);
}
else
{
// Schedule current trigger again firstly.
context.ScheduleActivity(transition.Trigger, this.onTriggerComplete);
this.currentRunningTriggers.Set(context, this.currentRunningTriggers.Get(context) + 1);
// check whether there is any other trigger completed.
ProcessNextTriggerCompletedEvent(context, eventManager);
}
}
}
void OnTriggerComplete(NativeActivityContext context, ActivityInstance completedInstance)
{
int runningTriggers = this.currentRunningTriggers.Get(context);
this.currentRunningTriggers.Set(context, --runningTriggers);
bool isOnExit = this.isExiting.Get(context);
if (!context.IsCancellationRequested && runningTriggers == 0 && isOnExit)
{
this.ScheduleExit(context);
}
else if (completedInstance.State == ActivityInstanceState.Closed)
{
InternalTransition internalTransition = null;
this.triggerInternalTransitionMapping.TryGetValue(completedInstance.Activity, out internalTransition);
Fx.Assert(internalTransition != null, "internalTransition should be added into triggerInternalTransitionMapping in CacheMetadata.");
StateMachineEventManager eventManager = this.EventManager.Get(context);
bool canBeProcessedImmediately;
eventManager.RegisterCompletedEvent(
new TriggerCompletedEvent { Bookmark = this.evaluateConditionBookmark.Get(context), TriggedId = internalTransition.InternalTransitionIndex },
out canBeProcessedImmediately);
if (canBeProcessedImmediately)
{
ProcessNextTriggerCompletedEvent(context, eventManager);
}
}
}
private void OnTriggerComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance)
{
int num = this.currentRunningTriggers.Get(context);
this.currentRunningTriggers.Set(context, --num);
bool flag = this.isExiting.Get(context);
if ((!context.IsCancellationRequested && (num == 0)) && flag)
{
this.ScheduleExit(context);
}
else if (completedInstance.State == ActivityInstanceState.Closed)
{
bool flag2;
InternalTransition transition = null;
this.triggerInternalTransitionMapping.TryGetValue(completedInstance.Activity, out transition);
StateMachineEventManager eventManager = this.EventManager.Get(context);
TriggerCompletedEvent completedEvent = new TriggerCompletedEvent {
Bookmark = this.evaluateConditionBookmark.Get(context),
TriggedId = transition.InternalTransitionIndex
};
eventManager.RegisterCompletedEvent(completedEvent, out flag2);
if (flag2)
{
ProcessNextTriggerCompletedEvent(context, eventManager);
}
}
}
private void OnConditionComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance, bool result)
{
StateMachineEventManager eventManager = this.EventManager.Get(context);
int triggedId = eventManager.CurrentBeingProcessedEvent.TriggedId;
if (result)
{
this.TakeTransition(context, eventManager, triggedId);
}
else
{
int currentConditionIndex = eventManager.CurrentConditionIndex;
InternalTransition internalTransition = this.GetInternalTransition(triggedId);
currentConditionIndex++;
if (currentConditionIndex < internalTransition.TransitionDataList.Count)
{
eventManager.CurrentConditionIndex = currentConditionIndex;
context.ScheduleActivity <bool>(internalTransition.TransitionDataList[currentConditionIndex].Condition, this.onConditionComplete, null);
}
else
{
context.ScheduleActivity(internalTransition.Trigger, this.onTriggerComplete);
this.currentRunningTriggers.Set(context, this.currentRunningTriggers.Get(context) + 1);
ProcessNextTriggerCompletedEvent(context, eventManager);
}
}
}
void TakeTransition(NativeActivityContext context, StateMachineEventManager eventManager, int triggerId)
{
this.EventManager.Get(context).OnTransition = true;
InternalTransition transition = this.GetInternalTransition(triggerId);
if (transition.IsUnconditional)
{
Fx.Assert(-1 == eventManager.CurrentConditionIndex, "CurrentConditionIndex should be -1, if the transition is unconditional.");
this.PrepareForExit(context, this.GetTo(triggerId));
}
else
{
Fx.Assert(-1 != eventManager.CurrentConditionIndex, "CurrentConditionIndex should not be -1, if the transition is conditional.");
this.PrepareForExit(context, this.GetTo(triggerId, eventManager.CurrentConditionIndex));
}
}
void ScheduleAction(NativeActivityContext context)
{
StateMachineEventManager eventManager = this.EventManager.Get(context);
if (eventManager.IsReferredByBeingProcessedEvent(this.evaluateConditionBookmark.Get(context)))
{
InternalTransition transition = this.GetInternalTransition(eventManager.CurrentBeingProcessedEvent.TriggedId);
Activity action = transition.TransitionDataList[-1 == eventManager.CurrentConditionIndex ? 0 : eventManager.CurrentConditionIndex].Action;
if (action != null)
{
context.ScheduleActivity(action);
}
}
this.RemoveBookmarks(context);
}
private void ProcessTransitions(NativeActivityMetadata metadata)
{
for (int i = 0; i < this.Transitions.Count; i++)
{
Transition transition = this.Transitions[i];
InternalTransition transition2 = null;
Activity activeTrigger = transition.ActiveTrigger;
if (!this.triggerInternalTransitionMapping.TryGetValue(activeTrigger, out transition2))
{
metadata.AddChild(activeTrigger);
transition2 = new InternalTransition {
Trigger = activeTrigger,
InternalTransitionIndex = this.internalTransitions.Count
};
this.triggerInternalTransitionMapping.Add(activeTrigger, transition2);
this.internalTransitions.Add(transition2);
}
AddTransitionData(metadata, transition2, transition);
}
}
void StartEvaluateCondition(NativeActivityContext context, Bookmark bookmark, object value)
{
// Start to evaluate conditions of the trigger which represented by currentTriggerIndex
StateMachineEventManager eventManager = this.EventManager.Get(context);
int triggerId = eventManager.CurrentBeingProcessedEvent.TriggedId;
InternalTransition transition = this.GetInternalTransition(triggerId);
if (transition.IsUnconditional)
{
eventManager.CurrentConditionIndex = -1;
this.TakeTransition(context, eventManager, triggerId);
}
else
{
eventManager.CurrentConditionIndex = 0;
context.ScheduleActivity<bool>(
this.GetCondition(
triggerId,
eventManager.CurrentConditionIndex),
this.onConditionComplete,
null);
}
}
private static bool ValidateDUInUnconditionalTransition(NativeActivityUpdateMapMetadata metadata, InternalTransition updatedTransition, InternalTransition originalTransition, out string errorMessage)
{
Fx.Assert(originalTransition.IsUnconditional, "Transition should be unconditional in the original definition.");
Activity originalAction = originalTransition.TransitionDataList[0].Action;
foreach (TransitionData transitionData in updatedTransition.TransitionDataList)
{
Activity updatedAction = transitionData.Action;
Activity actionMatch = metadata.GetMatch(updatedAction);
Activity conditionMatch = metadata.GetMatch(transitionData.Condition);
if ((null == originalAction && null != actionMatch) ||
(null != originalAction && null != actionMatch && !object.ReferenceEquals(originalAction, actionMatch)))
{
// Transition.Action is an activity moved from elsewhere within the InternalState
errorMessage = SR.MovingActivitiesInStateBlockDU;
return false;
}
}
errorMessage = string.Empty;
metadata.SaveOriginalValue(updatedTransition.Trigger, originalTransition.InternalTransitionIndex);
return true;
}
private static bool ValidateDUInConditionTransition(NativeActivityUpdateMapMetadata metadata, InternalTransition updatedTransition, InternalTransition originalTransition, out string errorMessage)
{
Fx.Assert(!originalTransition.IsUnconditional, "Transition should be conditional in the original definition.");
errorMessage = string.Empty;
foreach (TransitionData updatedTData in updatedTransition.TransitionDataList)
{
if (metadata.IsReferenceToImportedChild(updatedTData.Condition))
{
// if the trigger is referenced, it might have another save values already.
errorMessage = SR.TriggerOrConditionIsReferenced;
return false;
}
Fx.Assert(null != updatedTData.Condition, "Must be a condition transition.");
Activity conditionMatch = metadata.GetMatch(updatedTData.Condition);
if (null == conditionMatch && null != metadata.GetMatch(updatedTData.Action))
{
// new Transition.Condition with an Transition.Action moved from within the InternalState.
errorMessage = SR.MovingActivitiesInStateBlockDU;
return false;
}
else if (null != conditionMatch)
{
bool foundMatchingOriginalCondition = false;
for (int transitionIndex = 0; transitionIndex < originalTransition.TransitionDataList.Count; transitionIndex++)
{
if (object.ReferenceEquals(originalTransition.TransitionDataList[transitionIndex].Condition, conditionMatch))
{
foundMatchingOriginalCondition = true;
// found the original matching condition in updated transition definition.
TransitionData originalTData = originalTransition.TransitionDataList[transitionIndex];
Activity originalAction = originalTData.Action;
// NOTE: Transition.Action is allowed to be removed, because it doesn't change the execution semantics of SM
// if this removed activity was executing, WF runtime would disallow the update.
Activity actionMatch = metadata.GetMatch(updatedTData.Action);
if (null != actionMatch && !object.ReferenceEquals(originalAction, actionMatch))
{
// Transition.Action is an activity moved from elsewhere within the InternalState
errorMessage = SR.MovingActivitiesInStateBlockDU;
return false;
}
metadata.SaveOriginalValue(updatedTransition.Trigger, originalTransition.InternalTransitionIndex);
metadata.SaveOriginalValue(updatedTData.Condition, transitionIndex);
}
}
if (!foundMatchingOriginalCondition)
{
// another child activity is move to the Transition.Condition.
errorMessage = SR.DUDisallowIfCannotFindingMatchingCondition;
return false;
}
}
}
return true;
}
