internal static string GenerateValidationErrorPrefix(Activity toValidate, ActivityUtilities.ActivityCallStack parentChain, out Activity source) { bool flag = true; string str = ""; source = toValidate; for (int i = 0; i < parentChain.Count; i++) { ActivityUtilities.ChildActivity activity = parentChain[i]; if (activity.Activity.MemberOf.Parent != null) { flag = false; break; } } while (source.MemberOf.Parent != null) { source = source.Parent; } if (toValidate.MemberOf.Parent != null) { return System.Activities.SR.ValidationErrorPrefixForHiddenActivity(source); } if (!flag) { str = System.Activities.SR.ValidationErrorPrefixForPublicActivityWithHiddenParent(source.Parent, source); } return str; }
internal ValidationContext(ActivityUtilities.ChildActivity owner, ActivityUtilities.ActivityCallStack parentChain, ProcessActivityTreeOptions options, LocationReferenceEnvironment environment) { this.owner = owner; this.parentChain = parentChain; this.options = options; this.environment = environment; }
void AddBookmark(Bookmark bookmark, BookmarkCallback callback, ActivityInstance owningInstance, BookmarkOptions options) { if (this.bookmarks == null) { this.bookmarks = new Dictionary <Bookmark, BookmarkCallbackWrapper>(Bookmark.Comparer); } bookmark.Scope = this.scope; BookmarkCallbackWrapper bookmarkCallbackWrapper = new BookmarkCallbackWrapper(callback, owningInstance, options) { Bookmark = bookmark }; this.bookmarks.Add(bookmark, bookmarkCallbackWrapper); owningInstance.AddBookmark(bookmark, options); if (TD.CreateBookmarkIsEnabled()) { TD.CreateBookmark(owningInstance.Activity.GetType().ToString(), owningInstance.Activity.DisplayName, owningInstance.Id, ActivityUtilities.GetTraceString(bookmark), ActivityUtilities.GetTraceString((BookmarkScope)bookmark.Scope)); } }
internal void Validate(Activity owner, ref IList <ValidationError> validationErrors) { if (this.Expression != null) { if (this.Expression.Result != null && !this.Expression.Result.IsEmpty) { ValidationError validationError = new ValidationError(SR.ResultCannotBeSetOnArgumentExpressions, false, this.RuntimeArgument.Name, owner); ActivityUtilities.Add(ref validationErrors, validationError); } ActivityWithResult actualExpression = this.Expression; if (actualExpression is IExpressionWrapper) { actualExpression = ((IExpressionWrapper)actualExpression).InnerExpression; } switch (this.Direction) { case ArgumentDirection.In: if (actualExpression.ResultType != this.ArgumentType) { ActivityUtilities.Add( ref validationErrors, new ValidationError(SR.ArgumentValueExpressionTypeMismatch(this.ArgumentType, actualExpression.ResultType), false, this.RuntimeArgument.Name, owner)); } break; case ArgumentDirection.InOut: case ArgumentDirection.Out: Type locationType; if (!ActivityUtilities.IsLocationGenericType(actualExpression.ResultType, out locationType) || locationType != this.ArgumentType) { Type expectedType = ActivityUtilities.CreateActivityWithResult(ActivityUtilities.CreateLocation(this.ArgumentType)); ActivityUtilities.Add( ref validationErrors, new ValidationError(SR.ArgumentLocationExpressionTypeMismatch(expectedType.FullName, actualExpression.GetType().FullName), false, this.RuntimeArgument.Name, owner)); } break; } } }
public static Argument Create(Type type, ArgumentDirection direction) { return(ActivityUtilities.CreateArgument(type, direction)); }
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"); } } } }
private void ValidateElement(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain) { Activity objA = childActivity.Activity; if (!this.settings.SingleLevel || object.ReferenceEquals(objA, this.rootToValidate)) { if (this.settings.HasAdditionalConstraints) { bool suppressGetChildrenViolations = this.settings.OnlyUseAdditionalConstraints || this.settings.SingleLevel; for (Type type = objA.GetType(); type != null; type = type.BaseType) { IList<Constraint> list; if (this.settings.AdditionalConstraints.TryGetValue(type, out list)) { ActivityValidationServices.RunConstraints(childActivity, parentChain, list, this.options, suppressGetChildrenViolations, ref this.errors); } if (type.IsGenericType) { IList<Constraint> list2; Type genericTypeDefinition = type.GetGenericTypeDefinition(); if ((genericTypeDefinition != null) && this.settings.AdditionalConstraints.TryGetValue(genericTypeDefinition, out list2)) { ActivityValidationServices.RunConstraints(childActivity, parentChain, list2, this.options, suppressGetChildrenViolations, ref this.errors); } } } } if (childActivity.Activity.IsExpressionRoot) { if (childActivity.Activity.HasNonEmptySubtree) { this.expressionRoot = childActivity.Activity; ActivityUtilities.FinishCachingSubtree(childActivity, parentChain, ProcessActivityTreeOptions.FullCachingOptions, new ActivityUtilities.ProcessActivityCallback(this.ValidateExpressionSubtree)); this.expressionRoot = null; } else if (childActivity.Activity.InternalCanInduceIdle) { Activity activity = childActivity.Activity; RuntimeArgument boundRuntimeArgument = ActivityValidationServices.GetBoundRuntimeArgument(activity); ValidationError data = new ValidationError(System.Activities.SR.CanInduceIdleActivityInArgumentExpression(boundRuntimeArgument.Name, activity.Parent.DisplayName, activity.DisplayName), true, boundRuntimeArgument.Name, activity.Parent); ActivityUtilities.Add<ValidationError>(ref this.errors, data); } } } }
internal static List<Activity> GetChildren(ActivityUtilities.ChildActivity root, ActivityUtilities.ActivityCallStack parentChain, ProcessActivityTreeOptions options) { ActivityUtilities.FinishCachingSubtree(root, parentChain, options); List<Activity> list = new List<Activity>(); foreach (Activity activity in WorkflowInspectionServices.GetActivities(root.Activity)) { list.Add(activity); } for (int i = 0; i < list.Count; i++) { foreach (Activity activity2 in WorkflowInspectionServices.GetActivities(list[i])) { list.Add(activity2); } } return list; }
internal BookmarkScope CreateAndRegisterScope(Guid scopeId, BookmarkScopeHandle scopeHandle) { if (_bookmarkManagers == null) { _bookmarkManagers = new Dictionary <BookmarkScope, BookmarkManager>(); } BookmarkScope scope = null; if (scopeId == Guid.Empty) { // // This is the very first activity which started the sub-instance // scope = new BookmarkScope(GetNextTemporaryId()); _bookmarkManagers.Add(scope, new BookmarkManager(scope, scopeHandle)); if (TD.CreateBookmarkScopeIsEnabled()) { TD.CreateBookmarkScope(ActivityUtilities.GetTraceString(scope)); } if (_uninitializedScopes == null) { _uninitializedScopes = new List <BookmarkScope>(); } _uninitializedScopes.Add(scope); } else { // // Try to find one in the existing sub-instances // foreach (BookmarkScope eachScope in _bookmarkManagers.Keys) { if (eachScope.Id.Equals(scopeId)) { scope = eachScope; break; } } // // We did not find one, e.g. the first receive will get the correlation id from the // correlation channel // if (scope == null) { scope = new BookmarkScope(scopeId); _bookmarkManagers.Add(scope, new BookmarkManager(scope, scopeHandle)); if (TD.CreateBookmarkScopeIsEnabled()) { TD.CreateBookmarkScope(string.Format(CultureInfo.InvariantCulture, "Id: {0}", ActivityUtilities.GetTraceString(scope))); } } CreateAssociatedKey(scope); } return(scope); }
internal BookmarkScope CreateAndRegisterScope(Guid scopeId, BookmarkScopeHandle scopeHandle) { if (this.bookmarkManagers == null) { this.bookmarkManagers = new Dictionary <BookmarkScope, BookmarkManager>(); } BookmarkScope key = null; if (scopeId == Guid.Empty) { key = new BookmarkScope(this.GetNextTemporaryId()); this.bookmarkManagers.Add(key, new BookmarkManager(key, scopeHandle)); if (TD.CreateBookmarkScopeIsEnabled()) { TD.CreateBookmarkScope(ActivityUtilities.GetTraceString(key)); } if (this.uninitializedScopes == null) { this.uninitializedScopes = new List <BookmarkScope>(); } this.uninitializedScopes.Add(key); return(key); } foreach (BookmarkScope scope2 in this.bookmarkManagers.Keys) { if (scope2.Id.Equals(scopeId)) { key = scope2; break; } } if (key == null) { key = new BookmarkScope(scopeId); this.bookmarkManagers.Add(key, new BookmarkManager(key, scopeHandle)); if (TD.CreateBookmarkScopeIsEnabled()) { TD.CreateBookmarkScope(string.Format(CultureInfo.InvariantCulture, "Id: {0}", new object[] { ActivityUtilities.GetTraceString(key) })); } } this.CreateAssociatedKey(key); return(key); }
private void ValidateElement(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain) { Activity toValidate = childActivity.Activity; if (!_settings.SingleLevel || object.ReferenceEquals(toValidate, _rootToValidate)) { // 0. Open time violations are captured by the CacheMetadata walk. // 1. Argument validations are done by the CacheMetadata walk. // 2. Build constraints are done by the CacheMetadata walk. // 3. Then do policy constraints if (_settings.HasAdditionalConstraints && childActivity.CanBeExecuted && parentChain.WillExecute) { bool suppressGetChildrenViolations = _settings.OnlyUseAdditionalConstraints || _settings.SingleLevel; Type currentType = toValidate.GetType(); while (currentType != null) { IList <Constraint> policyConstraints; if (_settings.AdditionalConstraints.TryGetValue(currentType, out policyConstraints)) { RunConstraints(childActivity, parentChain, policyConstraints, _options, suppressGetChildrenViolations, ref _errors); } if (currentType.GetTypeInfo().IsGenericType) { Type genericDefinitionType = currentType.GetGenericTypeDefinition(); if (genericDefinitionType != null) { IList <Constraint> genericTypePolicyConstraints; if (_settings.AdditionalConstraints.TryGetValue(genericDefinitionType, out genericTypePolicyConstraints)) { RunConstraints(childActivity, parentChain, genericTypePolicyConstraints, _options, suppressGetChildrenViolations, ref _errors); } } } currentType = currentType.GetTypeInfo().BaseType; } } //4. Validate if the argument expression subtree contains an activity that can induce idle. if (childActivity.Activity.IsExpressionRoot) { if (childActivity.Activity.HasNonEmptySubtree) { _expressionRoot = childActivity.Activity; // Back-compat: In Dev10 we always used ProcessActivityTreeOptions.FullCachingOptions here, and ignored this.options. // So we need to continue to do that, unless the new Dev11 flag SkipRootConfigurationValidation is passed. ProcessActivityTreeOptions options = _options.SkipRootConfigurationValidation ? _options : ProcessActivityTreeOptions.FullCachingOptions; ActivityUtilities.FinishCachingSubtree(childActivity, parentChain, options, ValidateExpressionSubtree); _expressionRoot = null; } else if (childActivity.Activity.InternalCanInduceIdle) { Activity activity = childActivity.Activity; RuntimeArgument runtimeArgument = GetBoundRuntimeArgument(activity); ValidationError error = new ValidationError(SR.CanInduceIdleActivityInArgumentExpression(runtimeArgument.Name, activity.Parent.DisplayName, activity.DisplayName), true, runtimeArgument.Name, activity.Parent); ActivityUtilities.Add(ref _errors, error); } } } }
internal static void RunConstraints(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain, IList <Constraint> constraints, ProcessActivityTreeOptions options, bool suppressGetChildrenViolations, ref IList <ValidationError> validationErrors) { if (constraints != null) { Activity toValidate = childActivity.Activity; LocationReferenceEnvironment environment = toValidate.GetParentEnvironment(); Dictionary <string, object> inputDictionary = new Dictionary <string, object>(2); for (int constraintIndex = 0; constraintIndex < constraints.Count; constraintIndex++) { Constraint constraint = constraints[constraintIndex]; // there may be null entries here if (constraint == null) { continue; } inputDictionary[Constraint.ToValidateArgumentName] = toValidate; ValidationContext validationContext = new ValidationContext(childActivity, parentChain, options, environment); inputDictionary[Constraint.ToValidateContextArgumentName] = validationContext; IDictionary <string, object> results = null; try { results = WorkflowInvoker.Invoke(constraint, inputDictionary); } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } ValidationError constraintExceptionValidationError = new ValidationError(SR.InternalConstraintException(constraint.DisplayName, toValidate.GetType().FullName, toValidate.DisplayName, e.ToString()), false) { Source = toValidate, Id = toValidate.Id }; ActivityUtilities.Add(ref validationErrors, constraintExceptionValidationError); } if (results != null) { object resultValidationErrors; if (results.TryGetValue(Constraint.ValidationErrorListArgumentName, out resultValidationErrors)) { IList <ValidationError> validationErrorList = (IList <ValidationError>)resultValidationErrors; if (validationErrorList.Count > 0) { if (validationErrors == null) { validationErrors = new List <ValidationError>(); } Activity source; string prefix = ActivityValidationServices.GenerateValidationErrorPrefix(childActivity.Activity, parentChain, options, out source); for (int validationErrorIndex = 0; validationErrorIndex < validationErrorList.Count; validationErrorIndex++) { ValidationError validationError = validationErrorList[validationErrorIndex]; validationError.Source = source; validationError.Id = source.Id; if (!string.IsNullOrEmpty(prefix)) { validationError.Message = prefix + validationError.Message; } validationErrors.Add(validationError); } } } } if (!suppressGetChildrenViolations) { validationContext.AddGetChildrenErrors(ref validationErrors); } } } }
internal static void ValidateRootInputs(Activity rootActivity, IDictionary <string, object> inputs) { IList <ValidationError> validationErrors = null; ValidationHelper.ValidateArguments(rootActivity, rootActivity.EquivalenceInfo, rootActivity.OverloadGroups, rootActivity.RequiredArgumentsNotInOverloadGroups, inputs, ref validationErrors); // Validate if there are any extra arguments passed in the input dictionary if (inputs != null) { List <string> unusedArguments = null; IEnumerable <RuntimeArgument> arguments = rootActivity.RuntimeArguments.Where((a) => ArgumentDirectionHelper.IsIn(a.Direction)); foreach (string key in inputs.Keys) { bool found = false; foreach (RuntimeArgument argument in arguments) { if (argument.Name == key) { found = true; // Validate if the input argument type matches the expected argument type. object inputArgumentValue = null; if (inputs.TryGetValue(key, out inputArgumentValue)) { if (!TypeHelper.AreTypesCompatible(inputArgumentValue, argument.Type)) { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.InputParametersTypeMismatch(argument.Type, argument.Name), rootActivity)); } } // The ValidateArguments will validate Required in-args and hence not duplicating that validation if the key is not found. break; } } if (!found) { if (unusedArguments == null) { unusedArguments = new List <string>(); } unusedArguments.Add(key); } } if (unusedArguments != null) { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.UnusedInputArguments(unusedArguments.AsCommaSeparatedValues()), rootActivity)); } } if (validationErrors != null && validationErrors.Count > 0) { string parameterName = "rootArgumentValues"; ExceptionReason reason = ExceptionReason.InvalidNonNullInputs; if (inputs == null) { parameterName = "program"; reason = ExceptionReason.InvalidNullInputs; } string exceptionString = GenerateExceptionString(validationErrors, reason); if (exceptionString != null) { throw CoreWf.Internals.FxTrace.Exception.Argument(parameterName, exceptionString); } } }
public override void TraceScheduled() { if (TD.ScheduleBookmarkWorkItemIsEnabled()) { TD.ScheduleBookmarkWorkItem(this.ActivityInstance.Activity.GetType().ToString(), this.ActivityInstance.Activity.DisplayName, this.ActivityInstance.Id, ActivityUtilities.GetTraceString(this.bookmark), ActivityUtilities.GetTraceString(this.bookmark.Scope)); } }
private 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. var 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. var 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); } var pairsRemaining = new Queue <KeyValuePair <Activity, Activity> >(); pairsRemaining.Enqueue(new KeyValuePair <Activity, Activity>(rootActivity1, rootActivity2)); KeyValuePair <Activity, Activity> currentPair; var visited = new HashSet <Activity>(); while (pairsRemaining.Count > 0) { currentPair = pairsRemaining.Dequeue(); var activity1 = currentPair.Key; var 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))) { var enumerator1 = WorkflowInspectionServices.GetActivities(activity1).GetEnumerator(); var enumerator2 = WorkflowInspectionServices.GetActivities(activity2).GetEnumerator(); var hasNextItem1 = enumerator1.MoveNext(); var 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); } } }
internal void CreateArgument(LocationReference sourceReference, ArgumentDirection accessDirection, bool useLocationReferenceValue = false) { ActivityWithResult expression = ActivityUtilities.CreateLocationAccessExpression(sourceReference, accessDirection != ArgumentDirection.In, useLocationReferenceValue); AddGeneratedArgument(sourceReference.Type, accessDirection, expression); }
public static void ValidateArguments(Activity activity, OverloadGroupEquivalenceInfo equivalenceInfo, Dictionary <string, List <RuntimeArgument> > overloadGroups, List <RuntimeArgument> requiredArgumentsNotInOverloadGroups, IDictionary <string, object> inputs, ref IList <ValidationError> validationErrors) { if (!requiredArgumentsNotInOverloadGroups.IsNullOrEmpty()) { // 1. Check if there are any Required arguments (outside overload groups) that were not specified. foreach (RuntimeArgument argument in requiredArgumentsNotInOverloadGroups) { if (CheckIfArgumentIsNotBound(argument, inputs)) { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.RequiredArgumentValueNotSupplied(argument.Name), false, argument.Name, activity)); } } } if (!overloadGroups.IsNullOrEmpty()) { //1. Check to see if any of the overload groups are configured. // An overload group is considered to be completely configured if all it's required arguments // are non-null. If an overload group does not have any required arguments then the group is // considered configured if any of the optional arguments are configured. Dictionary <string, bool> configurationResults = new Dictionary <string, bool>(); string configuredGroupName = string.Empty; int configuredCount = 0; int overloadGroupsWithNoRequiredArgs = 0; foreach (KeyValuePair <string, List <RuntimeArgument> > entry in overloadGroups) { string groupName = entry.Key; configurationResults.Add(groupName, false); IEnumerable <RuntimeArgument> requiredArguments = entry.Value.Where((a) => a.IsRequired); if (requiredArguments.Count() > 0) { if (requiredArguments.All(localArgument => CheckIfArgumentIsBound(localArgument, inputs))) { configurationResults[groupName] = true; configuredGroupName = groupName; configuredCount++; } } else { overloadGroupsWithNoRequiredArgs++; IEnumerable <RuntimeArgument> optionalArguments = entry.Value.Where((a) => !a.IsRequired); if (optionalArguments.Any(localArgument => CheckIfArgumentIsBound(localArgument, inputs))) { configurationResults[groupName] = true; configuredGroupName = groupName; configuredCount++; } } } //2. It's an error if none of the groups are configured unless there // is atleast one overload group with no required arguments in it. if (configuredCount == 0) { if (overloadGroupsWithNoRequiredArgs == 0) { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.NoOverloadGroupsAreConfigured, false, activity)); } } //3. If only one overload group was configured, ensure none of the disjoint/overlapping groups have any // required or optional activity arguments set. else if (configuredCount == 1) { HashSet <RuntimeArgument> configuredOverloadSet = new HashSet <RuntimeArgument>(overloadGroups[configuredGroupName]); Predicate <RuntimeArgument> checkIfArgumentIsBound = new Predicate <RuntimeArgument>(localArgument => CheckIfArgumentIsBound(localArgument, inputs)); List <string> disjointGroups = null; if (!equivalenceInfo.DisjointGroupsDictionary.IsNullOrEmpty()) { equivalenceInfo.DisjointGroupsDictionary.TryGetValue(configuredGroupName, out disjointGroups); } List <string> overlappingGroups = null; if (!equivalenceInfo.OverlappingGroupsDictionary.IsNullOrEmpty()) { equivalenceInfo.OverlappingGroupsDictionary.TryGetValue(configuredGroupName, out overlappingGroups); } // Iterate over the groups that may not be completely configured. foreach (string groupName in configurationResults.Keys.Where((k) => configurationResults[k] == false)) { // Check if the partially configured group name is in the disjoint groups list. // If so, find all configured arguments. if (disjointGroups != null && disjointGroups.Contains(groupName)) { foreach (RuntimeArgument configuredArgument in overloadGroups[groupName].FindAll(checkIfArgumentIsBound)) { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ExtraOverloadGroupPropertiesConfigured(configuredGroupName, configuredArgument.Name, groupName), false, activity)); } } else if (overlappingGroups != null && overlappingGroups.Contains(groupName)) { // Find all arguments of the Overlapping group that are not in the configuredOverloadSet. HashSet <RuntimeArgument> overloadGroupSet = new HashSet <RuntimeArgument>(overloadGroups[groupName]); IEnumerable <RuntimeArgument> intersectSet = overloadGroupSet.Intersect(configuredOverloadSet); List <RuntimeArgument> exceptList = overloadGroupSet.Except(intersectSet).ToList(); foreach (RuntimeArgument configuredArgument in exceptList.FindAll(checkIfArgumentIsBound)) { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ExtraOverloadGroupPropertiesConfigured(configuredGroupName, configuredArgument.Name, groupName), false, activity)); } } } } //4. If more than one overload group is configured, generate an error. else { IEnumerable <string> configuredGroups = configurationResults.Keys.Where((k) => configurationResults[k]).OrderBy((k) => k, StringComparer.Ordinal); ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.MultipleOverloadGroupsConfigured(configuredGroups.AsCommaSeparatedValues()), false, activity)); } } }
internal static void RunConstraints(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain, IList<Constraint> constraints, ProcessActivityTreeOptions options, bool suppressGetChildrenViolations, ref IList<ValidationError> validationErrors) { if (constraints != null) { Activity activity = childActivity.Activity; LocationReferenceEnvironment parentEnvironment = activity.GetParentEnvironment(); Dictionary<string, object> inputs = new Dictionary<string, object>(2); for (int i = 0; i < constraints.Count; i++) { Constraint workflow = constraints[i]; if (workflow != null) { object obj2; inputs["ToValidate"] = activity; ValidationContext context = new ValidationContext(childActivity, parentChain, options, parentEnvironment); inputs["ToValidateContext"] = context; IDictionary<string, object> dictionary2 = null; try { dictionary2 = WorkflowInvoker.Invoke(workflow, inputs); } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } ValidationError data = new ValidationError(System.Activities.SR.InternalConstraintException(workflow.DisplayName, activity.GetType().FullName, activity.DisplayName, exception.ToString()), false) { Source = activity, Id = activity.Id }; ActivityUtilities.Add<ValidationError>(ref validationErrors, data); } if ((dictionary2 != null) && dictionary2.TryGetValue("ViolationList", out obj2)) { IList<ValidationError> list = (IList<ValidationError>) obj2; if (list.Count > 0) { Activity activity2; if (validationErrors == null) { validationErrors = new List<ValidationError>(); } string str = GenerateValidationErrorPrefix(childActivity.Activity, parentChain, out activity2); for (int j = 0; j < list.Count; j++) { ValidationError item = list[j]; item.Source = activity2; item.Id = activity2.Id; if (!string.IsNullOrEmpty(str)) { item.Message = str + item.Message; } validationErrors.Add(item); } } } if (!suppressGetChildrenViolations) { context.AddGetChildrenErrors(ref validationErrors); } } } } }
public override void TraceStarting() { if (TD.StartBookmarkWorkItemIsEnabled()) { TD.StartBookmarkWorkItem(this.ActivityInstance.Activity.GetType().ToString(), this.ActivityInstance.Activity.DisplayName, this.ActivityInstance.Id, ActivityUtilities.GetTraceString(Bookmark.AsyncOperationCompletionBookmark), ActivityUtilities.GetTraceString(Bookmark.AsyncOperationCompletionBookmark.Scope)); } }
private void ValidateExpressionSubtree(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain) { if (childActivity.Activity.InternalCanInduceIdle) { Activity activity = childActivity.Activity; Activity expressionRoot = this.expressionRoot; RuntimeArgument boundRuntimeArgument = ActivityValidationServices.GetBoundRuntimeArgument(expressionRoot); ValidationError data = new ValidationError(System.Activities.SR.CanInduceIdleActivityInArgumentExpression(boundRuntimeArgument.Name, expressionRoot.Parent.DisplayName, activity.DisplayName), true, boundRuntimeArgument.Name, expressionRoot.Parent); ActivityUtilities.Add<ValidationError>(ref this.errors, data); } }
internal void SetupBinding(Activity owningElement, bool createEmptyBinding) { if (this.bindingProperty != null) { Argument argument = (Argument)this.bindingProperty.GetValue(this.bindingPropertyOwner); if (argument == null) { Fx.Assert(this.bindingProperty.PropertyType.IsGenericType, "We only support arguments that are generic types in our reflection walk."); argument = (Argument)Activator.CreateInstance(this.bindingProperty.PropertyType); argument.WasDesignTimeNull = true; if (createEmptyBinding && !this.bindingProperty.IsReadOnly) { this.bindingProperty.SetValue(this.bindingPropertyOwner, argument); } } Argument.Bind(argument, this); } else if (!this.IsBound) { PropertyInfo targetProperty = null; foreach (var property in owningElement.GetType().GetProperties()) { if (property.Name == this.Name && property.PropertyType.GetTypeInfo().IsGenericType) { ArgumentDirection direction; Type argumentType; if (ActivityUtilities.TryGetArgumentDirectionAndType(property.PropertyType, out direction, out argumentType)) { if (this.Type == argumentType && this.Direction == direction) { targetProperty = property; break; } } } } Argument argument = null; if (targetProperty != null) { argument = (Argument)targetProperty.GetValue(owningElement); } if (argument == null) { if (targetProperty != null) { if (targetProperty.PropertyType.GetTypeInfo().IsGenericType) { argument = (Argument)Activator.CreateInstance(targetProperty.PropertyType); } else { argument = ActivityUtilities.CreateArgument(this.Type, this.Direction); } } else { argument = ActivityUtilities.CreateArgument(this.Type, this.Direction); } argument.WasDesignTimeNull = true; if (targetProperty != null && createEmptyBinding && targetProperty.CanWrite) { targetProperty.SetValue(owningElement, argument); } } Argument.Bind(argument, this); } Fx.Assert(this.IsBound, "We should always be bound when exiting this method."); }
public static Variable Create(string name, Type type, VariableModifiers modifiers) { return(ActivityUtilities.CreateVariable(name, type, modifiers)); }
public static void ValidateArguments(Activity activity, OverloadGroupEquivalenceInfo equivalenceInfo, Dictionary <string, List <RuntimeArgument> > overloadGroups, List <RuntimeArgument> requiredArgumentsNotInOverloadGroups, IDictionary <string, object> inputs, ref IList <ValidationError> validationErrors) { Func <RuntimeArgument, bool> func3 = null; Func <RuntimeArgument, bool> func4 = null; Predicate <RuntimeArgument> predicate2 = null; if (!requiredArgumentsNotInOverloadGroups.IsNullOrEmpty()) { foreach (RuntimeArgument argument in requiredArgumentsNotInOverloadGroups) { if (CheckIfArgumentIsNotBound(argument, inputs)) { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.RequiredArgumentValueNotSupplied(argument.Name), false, argument.Name, activity)); } } } if (!overloadGroups.IsNullOrEmpty()) { Func <string, bool> func = null; Func <string, bool> func2 = null; Dictionary <string, bool> configurationResults = new Dictionary <string, bool>(); string key = string.Empty; int num = 0; int num2 = 0; foreach (KeyValuePair <string, List <RuntimeArgument> > pair in overloadGroups) { string str2 = pair.Key; configurationResults.Add(str2, false); IEnumerable <RuntimeArgument> source = from a in pair.Value where a.IsRequired select a; if (source.Count <RuntimeArgument>() > 0) { if (func3 == null) { func3 = localArgument => CheckIfArgumentIsBound(localArgument, inputs); } if (source.All <RuntimeArgument>(func3)) { configurationResults[str2] = true; key = str2; num++; } } else { num2++; if (func4 == null) { func4 = localArgument => CheckIfArgumentIsBound(localArgument, inputs); } if ((from a in pair.Value where !a.IsRequired select a).Any <RuntimeArgument>(func4)) { configurationResults[str2] = true; key = str2; num++; } } } switch (num) { case 0: if (num2 == 0) { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.NoOverloadGroupsAreConfigured, false, activity)); return; } return; case 1: { HashSet <RuntimeArgument> second = new HashSet <RuntimeArgument>(overloadGroups[key]); if (predicate2 == null) { predicate2 = localArgument => CheckIfArgumentIsBound(localArgument, inputs); } Predicate <RuntimeArgument> match = predicate2; List <string> list = null; if (!equivalenceInfo.DisjointGroupsDictionary.IsNullOrEmpty()) { equivalenceInfo.DisjointGroupsDictionary.TryGetValue(key, out list); } List <string> list2 = null; if (!equivalenceInfo.OverlappingGroupsDictionary.IsNullOrEmpty()) { equivalenceInfo.OverlappingGroupsDictionary.TryGetValue(key, out list2); } if (func == null) { func = k => !configurationResults[k]; } foreach (string str3 in configurationResults.Keys.Where <string>(func)) { if ((list != null) && list.Contains(str3)) { foreach (RuntimeArgument argument2 in overloadGroups[str3].FindAll(match)) { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ExtraOverloadGroupPropertiesConfigured(key, argument2.Name, str3), false, activity)); } } else if ((list2 != null) && list2.Contains(str3)) { HashSet <RuntimeArgument> first = new HashSet <RuntimeArgument>(overloadGroups[str3]); IEnumerable <RuntimeArgument> enumerable3 = first.Intersect <RuntimeArgument>(second); foreach (RuntimeArgument argument3 in first.Except <RuntimeArgument>(enumerable3).ToList <RuntimeArgument>().FindAll(match)) { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ExtraOverloadGroupPropertiesConfigured(key, argument3.Name, str3), false, activity)); } } } return; } } if (func2 == null) { func2 = k => configurationResults[k]; } IEnumerable <string> c = configurationResults.Keys.Where <string>(func2).OrderBy <string, string>(k => k, StringComparer.Ordinal); ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.MultipleOverloadGroupsConfigured(c.AsCommaSeparatedValues()), false, activity)); } }