public static Activity Resolve(Activity root, string id)
{
if (root == null)
{
throw CoreWf.Internals.FxTrace.Exception.ArgumentNull("root");
}
if (string.IsNullOrEmpty(id))
{
throw CoreWf.Internals.FxTrace.Exception.ArgumentNullOrEmpty("id");
}
if (!root.IsMetadataCached)
{
IList <ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(root, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
}
QualifiedId parsedId = QualifiedId.Parse(id);
Activity result;
if (!QualifiedId.TryGetElementFromRoot(root, parsedId, out result))
{
throw CoreWf.Internals.FxTrace.Exception.Argument("id", SR.IdNotFoundInWorkflow(id));
}
return(result);
}
internal ValidationResults InternalValidate()
{
this.options = ProcessActivityTreeOptions.GetValidationOptions(this.settings);
if (this.settings.OnlyUseAdditionalConstraints)
{
IList <ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(this.rootToValidate, null, this.options, new ActivityUtilities.ProcessActivityCallback(this.ValidateElement), ref validationErrors);
}
else
{
ActivityUtilities.CacheRootMetadata(this.rootToValidate, null, this.options, new ActivityUtilities.ProcessActivityCallback(this.ValidateElement), ref this.errors);
}
return(new ValidationResults(this.errors));
}
internal ValidationResults InternalValidate()
{
this.options = ProcessActivityTreeOptions.GetValidationOptions(this.settings);
if (this.settings.OnlyUseAdditionalConstraints)
{
// We don't want the errors from CacheMetadata so we send those to a "dummy" list.
IList <ValidationError> suppressedErrors = null;
ActivityUtilities.CacheRootMetadata(this.rootToValidate, this.environment, this.options, new ActivityUtilities.ProcessActivityCallback(ValidateElement), ref suppressedErrors);
}
else
{
// We want to add the CacheMetadata errors to our errors collection
ActivityUtilities.CacheRootMetadata(this.rootToValidate, this.environment, this.options, new ActivityUtilities.ProcessActivityCallback(ValidateElement), ref this.errors);
}
return(new ValidationResults(this.errors));
}
public static bool CanInduceIdle(Activity activity)
{
if (activity == null)
{
throw CoreWf.Internals.FxTrace.Exception.ArgumentNull("activity");
}
if (!activity.IsMetadataCached)
{
IList <ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(activity, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
}
return(activity.InternalCanInduceIdle);
}
void ValidateWorkflow(WorkflowInstanceExtensionManager extensionManager)
{
if (!WorkflowDefinition.IsRuntimeReady)
{
LocationReferenceEnvironment localEnvironment = this.hostEnvironment;
if (localEnvironment == null)
{
LocationReferenceEnvironment parentEnvironment = null;
if (extensionManager != null && extensionManager.SymbolResolver != null)
{
parentEnvironment = extensionManager.SymbolResolver.AsLocationReferenceEnvironment();
}
localEnvironment = new ActivityLocationReferenceEnvironment(parentEnvironment);
}
IList <ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(WorkflowDefinition, localEnvironment, ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
}
}
// For most of the time, we need source location for object that appear on XAML.
// During debugging, however, we must not transform the internal activity to their origin to make sure it stop when the internal activity is about the execute
// Therefore, in debugger scenario, translateInternalActivityToOrigin will be set to false.
internal static Dictionary <object, SourceLocation> GetSourceLocations(Activity rootActivity, WorkflowSymbol symbol, bool translateInternalActivityToOrigin)
{
Activity workflowRoot = rootActivity.RootActivity ?? rootActivity;
if (!workflowRoot.IsMetadataFullyCached)
{
IList <ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(workflowRoot, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.ValidationOptions, null, ref validationErrors);
}
Dictionary <object, SourceLocation> newMapping = new Dictionary <object, SourceLocation>();
// Make sure the qid we are using to TryGetElementFromRoot
// are shifted appropriately such that the first digit that QID is
// the same as the last digit of the rootActivity.QualifiedId.
int[] rootIdArray = rootActivity.QualifiedId.AsIDArray();
int idOffset = rootIdArray[rootIdArray.Length - 1] - 1;
foreach (ActivitySymbol actSym in symbol.Symbols)
{
QualifiedId qid = new QualifiedId(actSym.QualifiedId);
if (idOffset != 0)
{
int[] idArray = qid.AsIDArray();
idArray[0] += idOffset;
qid = new QualifiedId(idArray);
}
Activity activity;
if (QualifiedId.TryGetElementFromRoot(rootActivity, qid, out activity))
{
object origin = activity;
if (translateInternalActivityToOrigin && activity.Origin != null)
{
origin = activity.Origin;
}
newMapping.Add(origin,
new SourceLocation(symbol.FileName, symbol.GetChecksum(), actSym.StartLine, actSym.StartColumn, actSym.EndLine, actSym.EndColumn));
}
}
return(newMapping);
}
private static bool RequiresCompilation(IDynamicActivity dynamicActivity, LocationReferenceEnvironment environment, out string language)
{
language = null;
if (!((Activity)dynamicActivity).IsMetadataCached)
{
IList <ValidationError> validationErrors = null;
if (environment == null)
{
environment = new ActivityLocationReferenceEnvironment {
CompileExpressions = true
};
}
try
{
ActivityUtilities.CacheRootMetadata((Activity)dynamicActivity, environment, ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.CompiledExpressionsCacheMetadataException(dynamicActivity.Name, e.ToString())));
}
}
DynamicActivityVisitor vistor = new DynamicActivityVisitor();
vistor.Visit((Activity)dynamicActivity, true);
if (!vistor.RequiresCompilation)
{
return(false);
}
if (vistor.HasLanguageConflict)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.DynamicActivityMultipleExpressionLanguages(vistor.GetConflictingLanguages().AsCommaSeparatedValues())));
}
language = vistor.Language;
return(true);
}
public static ICollection <ActivitySymbol> GetSymbols(Activity rootActivity, Dictionary <object, SourceLocation> sourceLocations)
{
List <ActivitySymbol> symbols = new List <ActivitySymbol>();
Activity realRoot = (rootActivity.RootActivity != null) ? rootActivity.RootActivity : rootActivity;
if (!realRoot.IsMetadataFullyCached)
{
IList <ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(realRoot, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.ValidationOptions, null, ref validationErrors);
}
Queue <Activity> activitiesRemaining = new Queue <Activity>();
activitiesRemaining.Enqueue(realRoot);
HashSet <Activity> visited = new HashSet <Activity>();
while (activitiesRemaining.Count > 0)
{
Activity currentActivity = activitiesRemaining.Dequeue();
SourceLocation sourceLocation;
object origin = currentActivity.Origin == null ? currentActivity : currentActivity.Origin;
if (!visited.Contains(currentActivity) && sourceLocations.TryGetValue(origin, out sourceLocation))
{
symbols.Add(new ActivitySymbol
{
QualifiedId = currentActivity.QualifiedId.AsByteArray(),
StartLine = sourceLocation.StartLine,
StartColumn = sourceLocation.StartColumn,
EndLine = sourceLocation.EndLine,
EndColumn = sourceLocation.EndColumn
});
}
visited.Add(currentActivity);
foreach (Activity childActivity in WorkflowInspectionServices.GetActivities(currentActivity))
{
activitiesRemaining.Enqueue(childActivity);
}
}
return(symbols);
}
public static void CacheMetadata(Activity rootActivity, LocationReferenceEnvironment hostEnvironment)
{
if (rootActivity == null)
{
throw CoreWf.Internals.FxTrace.Exception.ArgumentNull("rootActivity");
}
if (rootActivity.HasBeenAssociatedWithAnInstance)
{
throw CoreWf.Internals.FxTrace.Exception.AsError(new InvalidOperationException(SR.RootActivityAlreadyAssociatedWithInstance(rootActivity.DisplayName)));
}
IList <ValidationError> validationErrors = null;
if (hostEnvironment == null)
{
hostEnvironment = new ActivityLocationReferenceEnvironment();
}
ActivityUtilities.CacheRootMetadata(rootActivity, hostEnvironment, ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
}
static void CollectMapping(Activity rootActivity1, Activity rootActivity2, Dictionary <object, SourceLocation> mapping, string path, byte[] checksum, bool requirePrepareForRuntime)
{
// For x:Class, the rootActivity here may not be the real root, but it's the first child of the x:Class activity.
Activity realRoot1 = (rootActivity1.RootActivity != null) ? rootActivity1.RootActivity : rootActivity1;
if ((requirePrepareForRuntime && !realRoot1.IsRuntimeReady) || (!requirePrepareForRuntime && !realRoot1.IsMetadataFullyCached))
{
IList <ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(realRoot1, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.ValidationOptions, null, ref validationErrors);
}
// Similarly for rootActivity2.
Activity realRoot2 = (rootActivity2.RootActivity != null) ? rootActivity2.RootActivity : rootActivity2;
if (rootActivity1 != rootActivity2 && (requirePrepareForRuntime && !realRoot2.IsRuntimeReady) || (!requirePrepareForRuntime && !realRoot2.IsMetadataFullyCached))
{
IList <ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(realRoot2, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.ValidationOptions, null, ref validationErrors);
}
Queue <KeyValuePair <Activity, Activity> > pairsRemaining = new Queue <KeyValuePair <Activity, Activity> >();
pairsRemaining.Enqueue(new KeyValuePair <Activity, Activity>(rootActivity1, rootActivity2));
KeyValuePair <Activity, Activity> currentPair;
HashSet <Activity> visited = new HashSet <Activity>();
while (pairsRemaining.Count > 0)
{
currentPair = pairsRemaining.Dequeue();
Activity activity1 = currentPair.Key;
Activity activity2 = currentPair.Value;
visited.Add(activity1);
SourceLocation sourceLocation;
if (TryGetSourceLocation(activity2, path, checksum, out sourceLocation))
{
mapping.Add(activity1, sourceLocation);
}
else if (!((activity2 is IExpressionContainer) || (activity2 is IValueSerializableExpression))) // Expression is known not to have source location.
{
//Some activities may not have corresponding Xaml node, e.g. ActivityFaultedOutput.
Trace.WriteLine("WorkflowDebugger: Does not have corresponding Xaml node for: " + activity2.DisplayName + "\n");
}
// This to avoid comparing any value expression with DesignTimeValueExpression (in designer case).
if (!((activity1 is IExpressionContainer) || (activity2 is IExpressionContainer) ||
(activity1 is IValueSerializableExpression) || (activity2 is IValueSerializableExpression)))
{
IEnumerator <Activity> enumerator1 = WorkflowInspectionServices.GetActivities(activity1).GetEnumerator();
IEnumerator <Activity> enumerator2 = WorkflowInspectionServices.GetActivities(activity2).GetEnumerator();
bool hasNextItem1 = enumerator1.MoveNext();
bool hasNextItem2 = enumerator2.MoveNext();
while (hasNextItem1 && hasNextItem2)
{
if (!visited.Contains(enumerator1.Current)) // avoid adding the same activity (e.g. some default implementation).
{
if (enumerator1.Current.GetType() != enumerator2.Current.GetType())
{
// Give debugger log instead of just asserting; to help user find out mismatch problem.
Trace.WriteLine(
"Unmatched type: " + enumerator1.Current.GetType().FullName +
" vs " + enumerator2.Current.GetType().FullName + "\n");
}
pairsRemaining.Enqueue(new KeyValuePair <Activity, Activity>(enumerator1.Current, enumerator2.Current));
}
hasNextItem1 = enumerator1.MoveNext();
hasNextItem2 = enumerator2.MoveNext();
}
// If enumerators do not finish at the same time, then they have unmatched number of activities.
// Give debugger log instead of just asserting; to help user find out mismatch problem.
if (hasNextItem1 || hasNextItem2)
{
Trace.WriteLine("Unmatched number of children\n");
}
}
}
}
public static IEnumerable <Activity> GetActivities(Activity activity)
{
if (activity == null)
{
throw CoreWf.Internals.FxTrace.Exception.ArgumentNull("activity");
}
if (!activity.IsMetadataCached)
{
IList <ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(activity, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
}
int i = 0;
for (; i < activity.RuntimeArguments.Count; i++)
{
RuntimeArgument argument = activity.RuntimeArguments[i];
if (argument.BoundArgument != null && argument.BoundArgument.Expression != null)
{
yield return(argument.BoundArgument.Expression);
}
}
for (i = 0; i < activity.RuntimeVariables.Count; i++)
{
Variable variable = activity.RuntimeVariables[i];
if (variable.Default != null)
{
yield return(variable.Default);
}
}
for (i = 0; i < activity.ImplementationVariables.Count; i++)
{
Variable variable = activity.ImplementationVariables[i];
if (variable.Default != null)
{
yield return(variable.Default);
}
}
for (i = 0; i < activity.Children.Count; i++)
{
yield return(activity.Children[i]);
}
for (i = 0; i < activity.ImportedChildren.Count; i++)
{
yield return(activity.ImportedChildren[i]);
}
for (i = 0; i < activity.ImplementationChildren.Count; i++)
{
yield return(activity.ImplementationChildren[i]);
}
for (i = 0; i < activity.Delegates.Count; i++)
{
ActivityDelegate activityDelegate = activity.Delegates[i];
if (activityDelegate.Handler != null)
{
yield return(activityDelegate.Handler);
}
}
for (i = 0; i < activity.ImportedDelegates.Count; i++)
{
ActivityDelegate activityDelegate = activity.ImportedDelegates[i];
if (activityDelegate.Handler != null)
{
yield return(activityDelegate.Handler);
}
}
for (i = 0; i < activity.ImplementationDelegates.Count; i++)
{
ActivityDelegate activityDelegate = activity.ImplementationDelegates[i];
if (activityDelegate.Handler != null)
{
yield return(activityDelegate.Handler);
}
}
}
public static void CollectMapping(Activity rootActivity1, Activity rootActivity2, Dictionary <object, SourceLocation> mapping, string path)
{
Activity activity = (rootActivity1.RootActivity != null) ? rootActivity1.RootActivity : rootActivity1;
if (!activity.IsRuntimeReady)
{
IList <ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(activity, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.ValidationOptions, null, ref validationErrors);
}
Activity activity2 = (rootActivity2.RootActivity != null) ? rootActivity2.RootActivity : rootActivity2;
if (!activity2.IsRuntimeReady)
{
IList <ValidationError> list2 = null;
ActivityUtilities.CacheRootMetadata(activity2, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.ValidationOptions, null, ref list2);
}
Queue <KeyValuePair <Activity, Activity> > queue = new Queue <KeyValuePair <Activity, Activity> >();
queue.Enqueue(new KeyValuePair <Activity, Activity>(rootActivity1, rootActivity2));
System.Collections.Generic.HashSet <Activity> set = new System.Collections.Generic.HashSet <Activity>();
while (queue.Count > 0)
{
SourceLocation location;
KeyValuePair <Activity, Activity> pair = queue.Dequeue();
Activity key = pair.Key;
Activity activity4 = pair.Value;
set.Add(key);
if (TryGetSourceLocation(activity4, path, out location))
{
mapping.Add(key, location);
}
else if (!(activity4 is IExpressionContainer) && !(activity4 is IValueSerializableExpression))
{
Debugger.Log(2, "Workflow", "WorkflowDebugger: Does not have corresponding Xaml node for: " + activity4.DisplayName + "\n");
}
if ((!(key is IExpressionContainer) && !(activity4 is IExpressionContainer)) && (!(key is IValueSerializableExpression) && !(activity4 is IValueSerializableExpression)))
{
IEnumerator <Activity> enumerator = WorkflowInspectionServices.GetActivities(key).GetEnumerator();
IEnumerator <Activity> enumerator2 = WorkflowInspectionServices.GetActivities(activity4).GetEnumerator();
bool flag = enumerator.MoveNext();
bool flag2 = enumerator2.MoveNext();
while (flag && flag2)
{
if (!set.Contains(enumerator.Current))
{
if (enumerator.Current.GetType() != enumerator2.Current.GetType())
{
Debugger.Log(2, "Workflow", "Unmatched type: " + enumerator.Current.GetType().FullName + " vs " + enumerator2.Current.GetType().FullName + "\n");
}
queue.Enqueue(new KeyValuePair <Activity, Activity>(enumerator.Current, enumerator2.Current));
}
flag = enumerator.MoveNext();
flag2 = enumerator2.MoveNext();
}
if (flag || flag2)
{
Debugger.Log(2, "Workflow", "Unmatched number of children\n");
}
}
}
}