public void SetValidationErrorsCollection(Collection <ValidationError> validationErrors) { this.ThrowIfDisposed(); ActivityUtilities.RemoveNulls(validationErrors); this.activity.SetTempValidationErrorCollection(validationErrors); }
public void SetImportedDelegatesCollection(Collection <ActivityDelegate> importedDelegates) { this.ThrowIfDisposed(); ActivityUtilities.RemoveNulls(importedDelegates); this.activity.SetImportedDelegatesCollection(importedDelegates); }
public void SetVariablesCollection(Collection <Variable> variables) { this.ThrowIfDisposed(); ActivityUtilities.RemoveNulls(variables); this.activity.SetVariablesCollection(variables); }
public void SetArgumentsCollection(Collection <RuntimeArgument> arguments) { this.ThrowIfDisposed(); ActivityUtilities.RemoveNulls(arguments); this.activity.SetArgumentsCollection(arguments, this.createEmptyBindings); }
public void SetImportedChildrenCollection(Collection <Activity> importedChildren) { this.ThrowIfDisposed(); ActivityUtilities.RemoveNulls(importedChildren); this.activity.SetImportedChildrenCollection(importedChildren); }
public Variable() { base.IsHandle = ActivityUtilities.IsHandle(typeof(T)); }
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) { PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(owningElement); PropertyDescriptor targetProperty = null; for (int i = 0; i < properties.Count; i++) { PropertyDescriptor property = properties[i]; // We only support auto-setting the property // for generic types. Otherwise we have no // guarantee that the argument returned by the // property still matches the runtime argument's // type. if (property.Name == this.Name && property.PropertyType.IsGenericType) { if (ActivityUtilities.TryGetArgumentDirectionAndType(property.PropertyType, out ArgumentDirection direction, out Type 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.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.IsReadOnly) { targetProperty.SetValue(owningElement, argument); } } Argument.Bind(argument, this); } Fx.Assert(this.IsBound, "We should always be bound when exiting this method."); }
public static Argument Create(Type type, ArgumentDirection direction) { return(ActivityUtilities.CreateArgument(type, direction)); }
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 IEnumerable <Activity> GetActivities(Activity activity) { if (activity == null) { throw 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 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)); } }
internal void SetupBinding(Activity owningElement, bool createEmptyBinding) { if (this.bindingProperty != null) { Argument argument = (Argument)this.bindingProperty.GetValue(this.bindingPropertyOwner); if (argument == null) { 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) { PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(owningElement); PropertyDescriptor descriptor = null; for (int i = 0; i < properties.Count; i++) { ArgumentDirection direction; Type type; PropertyDescriptor descriptor2 = properties[i]; if ((((descriptor2.Name == base.Name) && descriptor2.PropertyType.IsGenericType) && (ActivityUtilities.TryGetArgumentDirectionAndType(descriptor2.PropertyType, out direction, out type) && (base.Type == type))) && (this.Direction == direction)) { descriptor = descriptor2; break; } } Argument argument2 = null; if (descriptor != null) { argument2 = (Argument)descriptor.GetValue(owningElement); } if (argument2 == null) { if (descriptor != null) { if (descriptor.PropertyType.IsGenericType) { argument2 = (Argument)Activator.CreateInstance(descriptor.PropertyType); } else { argument2 = ActivityUtilities.CreateArgument(base.Type, this.Direction); } } else { argument2 = ActivityUtilities.CreateArgument(base.Type, this.Direction); } argument2.WasDesignTimeNull = true; if (((descriptor != null) && createEmptyBinding) && !descriptor.IsReadOnly) { descriptor.SetValue(owningElement, argument2); } } Argument.Bind(argument2, this); } }
public static Variable Create(string name, Type type, VariableModifiers modifiers) { return(ActivityUtilities.CreateVariable(name, type, modifiers)); }
public static IEnumerable <Activity> GetActivities(Activity activity) { int iteratorVariable0; if (activity == null) { throw FxTrace.Exception.ArgumentNull("activity"); } if (!activity.IsMetadataCached) { IList <ValidationError> validationErrors = null; ActivityUtilities.CacheRootMetadata(activity, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors); ActivityValidationServices.ThrowIfViolationsExist(validationErrors); } for (iteratorVariable0 = 0; iteratorVariable0 < activity.RuntimeArguments.Count; iteratorVariable0++) { RuntimeArgument iteratorVariable1 = activity.RuntimeArguments[iteratorVariable0]; if ((iteratorVariable1.BoundArgument != null) && (iteratorVariable1.BoundArgument.Expression != null)) { yield return(iteratorVariable1.BoundArgument.Expression); } } for (iteratorVariable0 = 0; iteratorVariable0 < activity.RuntimeVariables.Count; iteratorVariable0++) { Variable iteratorVariable2 = activity.RuntimeVariables[iteratorVariable0]; if (iteratorVariable2.Default != null) { yield return(iteratorVariable2.Default); } } for (iteratorVariable0 = 0; iteratorVariable0 < activity.ImplementationVariables.Count; iteratorVariable0++) { Variable iteratorVariable3 = activity.ImplementationVariables[iteratorVariable0]; if (iteratorVariable3.Default != null) { yield return(iteratorVariable3.Default); } } for (iteratorVariable0 = 0; iteratorVariable0 < activity.Children.Count; iteratorVariable0++) { yield return(activity.Children[iteratorVariable0]); } for (iteratorVariable0 = 0; iteratorVariable0 < activity.ImportedChildren.Count; iteratorVariable0++) { yield return(activity.ImportedChildren[iteratorVariable0]); } for (iteratorVariable0 = 0; iteratorVariable0 < activity.ImplementationChildren.Count; iteratorVariable0++) { yield return(activity.ImplementationChildren[iteratorVariable0]); } for (iteratorVariable0 = 0; iteratorVariable0 < activity.Delegates.Count; iteratorVariable0++) { ActivityDelegate iteratorVariable4 = activity.Delegates[iteratorVariable0]; if (iteratorVariable4.Handler != null) { yield return(iteratorVariable4.Handler); } } for (iteratorVariable0 = 0; iteratorVariable0 < activity.ImportedDelegates.Count; iteratorVariable0++) { ActivityDelegate iteratorVariable5 = activity.ImportedDelegates[iteratorVariable0]; if (iteratorVariable5.Handler != null) { yield return(iteratorVariable5.Handler); } } for (iteratorVariable0 = 0; iteratorVariable0 < activity.ImplementationDelegates.Count; iteratorVariable0++) { ActivityDelegate iteratorVariable6 = activity.ImplementationDelegates[iteratorVariable0]; if (iteratorVariable6.Handler != null) { yield return(iteratorVariable6.Handler); } } }
internal bool InitializeRelationship(Activity parent, ActivityCollectionType collectionType, ref IList <ValidationError> validationErrors) { if (this.cacheId == parent.CacheId) { Fx.Assert(this.owner != null, "We must have set the owner when we set the cache ID"); // This means that we've already encountered a parent in the tree // Validate that it is visible. // In order to see the activity the new parent must be // in the implementation IdSpace of an activity which has // a public reference to it. Activity referenceTarget = parent.MemberOf.Owner; if (referenceTarget == null) { Activity handler = this.Handler; if (handler == null) { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityDelegateCannotBeReferencedWithoutTargetNoHandler(parent.DisplayName, this.owner.DisplayName), false, parent)); } else { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityDelegateCannotBeReferencedWithoutTarget(handler.DisplayName, parent.DisplayName, this.owner.DisplayName), false, parent)); } return(false); } else if (!referenceTarget.Delegates.Contains(this) && !referenceTarget.ImportedDelegates.Contains(this)) { Activity handler = this.Handler; if (handler == null) { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityDelegateCannotBeReferencedNoHandler(parent.DisplayName, referenceTarget.DisplayName, this.owner.DisplayName), false, parent)); } else { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ActivityDelegateCannotBeReferenced(handler.DisplayName, parent.DisplayName, referenceTarget.DisplayName, this.owner.DisplayName), false, parent)); } return(false); } // This is a valid reference so we want to allow // normal processing to proceed. return(true); } this.owner = parent; this.cacheId = parent.CacheId; this.parentCollectionType = collectionType; InternalCacheMetadata(); // We need to setup the delegate environment so that it is // available when we process the Handler. LocationReferenceEnvironment delegateEnvironment = null; if (collectionType == ActivityCollectionType.Implementation) { delegateEnvironment = parent.ImplementationEnvironment; } else { delegateEnvironment = parent.PublicEnvironment; } if (this.RuntimeDelegateArguments.Count > 0) { ActivityLocationReferenceEnvironment newEnvironment = new ActivityLocationReferenceEnvironment(delegateEnvironment); delegateEnvironment = newEnvironment; for (int argumentIndex = 0; argumentIndex < this.RuntimeDelegateArguments.Count; argumentIndex++) { RuntimeDelegateArgument runtimeDelegateArgument = this.RuntimeDelegateArguments[argumentIndex]; DelegateArgument delegateArgument = runtimeDelegateArgument.BoundArgument; if (delegateArgument != null) { if (delegateArgument.Direction != runtimeDelegateArgument.Direction) { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.RuntimeDelegateArgumentDirectionIncorrect, parent)); } if (delegateArgument.Type != runtimeDelegateArgument.Type) { ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.RuntimeDelegateArgumentTypeIncorrect, parent)); } // NOTE: We don't initialize this relationship here because // at runtime we'll actually just place these variables in the // environment of the Handler. We'll initialize and set an // ID when we process the Handler. newEnvironment.Declare(delegateArgument, this.owner, ref validationErrors); } } } this.Environment = delegateEnvironment; if (this.Handler != null) { return(this.Handler.InitializeRelationship(this, collectionType, ref validationErrors)); } return(true); }
public void SetImplementationVariablesCollection(Collection <Variable> implementationVariables) { this.ThrowIfDisposed(); ActivityUtilities.RemoveNulls(implementationVariables); this.activity.SetImplementationVariablesCollection(implementationVariables); }