public void Declare(LocationReference locationReference, Activity owner, ref IList <ValidationError> validationErrors) { if (locationReference.Name == null) { if (this.unnamedDeclarations == null) { this.unnamedDeclarations = new List <LocationReference>(); } this.unnamedDeclarations.Add(locationReference); } else if (this.Declarations.ContainsKey(locationReference.Name)) { string id = null; if (owner != null) { id = owner.Id; } ValidationError data = new ValidationError(System.Activities.SR.SymbolNamesMustBeUnique(locationReference.Name)) { Source = owner, Id = id }; ActivityUtilities.Add <ValidationError>(ref validationErrors, data); } else { this.Declarations.Add(locationReference.Name, locationReference); } }
internal bool InitializeRelationship(Activity parent, ref IList <ValidationError> validationErrors) { if (this.cacheId == parent.CacheId) { if (this.Owner == parent) { ActivityUtilities.Add <ValidationError>(ref validationErrors, this.ProcessViolation(parent, System.Activities.SR.ArgumentIsAddedMoreThanOnce(base.Name, this.Owner.DisplayName))); return(false); } ActivityUtilities.Add <ValidationError>(ref validationErrors, this.ProcessViolation(parent, System.Activities.SR.ArgumentAlreadyInUse(base.Name, this.Owner.DisplayName, parent.DisplayName))); return(false); } if ((this.boundArgument != null) && (this.boundArgument.RuntimeArgument != this)) { ActivityUtilities.Add <ValidationError>(ref validationErrors, this.ProcessViolation(parent, System.Activities.SR.RuntimeArgumentBindingInvalid(base.Name, this.boundArgument.RuntimeArgument.Name))); return(false); } this.Owner = parent; this.cacheId = parent.CacheId; if (this.boundArgument != null) { this.boundArgument.Validate(parent, ref validationErrors); if (!this.BoundArgument.IsEmpty) { return(this.BoundArgument.Expression.InitializeRelationship(this, ref validationErrors)); } } return(true); }
internal bool InitializeRelationship(Activity parent, bool isPublic, ref IList <ValidationError> validationErrors) { if ((this.cacheId == parent.CacheId) && (this.Owner != null)) { ValidationError data = new ValidationError(System.Activities.SR.VariableAlreadyInUseOnActivity(this.Name, parent.DisplayName, this.Owner.DisplayName), false, this.Name, parent); ActivityUtilities.Add <ValidationError>(ref validationErrors, data); return(false); } this.Owner = parent; this.cacheId = parent.CacheId; this.IsPublic = isPublic; if (this.Default == null) { return(true); } ActivityWithResult innerExpression = this.Default; if (innerExpression is Argument.IExpressionWrapper) { innerExpression = ((Argument.IExpressionWrapper)innerExpression).InnerExpression; } if (innerExpression.ResultType != base.Type) { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.VariableExpressionTypeMismatch(this.Name, base.Type, innerExpression.ResultType), false, this.Name, parent)); } return(this.Default.InitializeRelationship(this, isPublic, ref validationErrors)); }
internal bool InitializeRelationship(Activity parent, ref IList <ValidationError> validationErrors) { if (this.cacheId == parent.CacheId) { // We're part of the same tree walk if (this.Owner == parent) { ActivityUtilities.Add(ref validationErrors, this.ProcessViolation(parent, SR.ArgumentIsAddedMoreThanOnce(this.Name, this.Owner.DisplayName))); // Get out early since we've already initialized this argument. return(false); } Fx.Assert(this.Owner != null, "We must have already assigned an owner."); ActivityUtilities.Add( ref validationErrors, this.ProcessViolation( parent, SR.ArgumentAlreadyInUse( this.Name, this.Owner?.DisplayName, parent.DisplayName))); // Get out early since we've already initialized this argument. return(false); } if (this.BoundArgument != null && this.BoundArgument.RuntimeArgument != this) { ActivityUtilities.Add( ref validationErrors, this.ProcessViolation( parent, SR.RuntimeArgumentBindingInvalid( this.Name, this.BoundArgument.RuntimeArgument?.Name))); return(false); } this.Owner = parent; this.cacheId = parent.CacheId; if (this.BoundArgument != null) { this.BoundArgument.Validate(parent, ref validationErrors); if (!(this.BoundArgument?.IsEmpty ?? true)) { return(this.BoundArgument?.Expression?.InitializeRelationship(this, ref validationErrors) ?? false); } } return(true); }
internal bool InitializeRelationship(Activity parent, ref IList <ValidationError> validationErrors) { if (this.cacheId == parent.CacheId) { ValidationError data = new ValidationError(System.Activities.SR.DelegateArgumentAlreadyInUseOnActivity(this.Name, parent.DisplayName, this.Owner.DisplayName), this.Owner); ActivityUtilities.Add <ValidationError>(ref validationErrors, data); return(false); } this.Owner = parent; this.cacheId = parent.CacheId; return(true); }
internal bool InitializeRelationship(Activity parent, ref IList <ValidationError> validationErrors) { if (this.cacheId == parent.CacheId) { Fx.Assert(this.Owner != null, "must have an owner here"); var validationError = new ValidationError(SR.DelegateArgumentAlreadyInUseOnActivity(this.Name, parent.DisplayName, this.Owner.DisplayName), this.Owner); ActivityUtilities.Add(ref validationErrors, validationError); // Get out early since we've already initialized this argument. return(false); } this.Owner = parent; this.cacheId = parent.CacheId; return(true); }
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; } } }
internal bool InitializeRelationship(Activity parent, bool isPublic, ref IList <ValidationError> validationErrors) { if (this.cacheId == parent.CacheId) { if (this.Owner != null) { ValidationError validationError = new ValidationError(SR.VariableAlreadyInUseOnActivity(this.Name, parent.DisplayName, this.Owner.DisplayName), false, this.Name, parent); ActivityUtilities.Add(ref validationErrors, validationError); // Get out early since we've already initialized this variable. return(false); } } this.Owner = parent; this.cacheId = parent.CacheId; this.IsPublic = isPublic; if (this.Default != null) { ActivityWithResult expression = this.Default; if (expression is Argument.IExpressionWrapper) { expression = ((Argument.IExpressionWrapper)expression).InnerExpression; } if (expression.ResultType != this.Type) { ActivityUtilities.Add( ref validationErrors, new ValidationError(SR.VariableExpressionTypeMismatch(this.Name, this.Type, expression.ResultType), false, this.Name, parent)); } return(this.Default.InitializeRelationship(this, isPublic, ref validationErrors)); } return(true); }
internal void Validate(Activity owner, ref IList <ValidationError> validationErrors) { if (this.Expression != null) { if ((this.Expression.Result != null) && !this.Expression.Result.IsEmpty) { ValidationError data = new ValidationError(System.Activities.SR.ResultCannotBeSetOnArgumentExpressions, false, this.RuntimeArgument.Name, owner); ActivityUtilities.Add <ValidationError>(ref validationErrors, data); } ActivityWithResult expression = this.Expression; if (expression is IExpressionWrapper) { expression = ((IExpressionWrapper)expression).InnerExpression; } switch (this.Direction) { case ArgumentDirection.In: if (!(expression.ResultType != this.ArgumentType)) { break; } ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ArgumentValueExpressionTypeMismatch(this.ArgumentType, expression.ResultType), false, this.RuntimeArgument.Name, owner)); return; case ArgumentDirection.Out: case ArgumentDirection.InOut: Type type; if (!ActivityUtilities.IsLocationGenericType(expression.ResultType, out type) || (type != this.ArgumentType)) { Type type2 = ActivityUtilities.CreateActivityWithResult(ActivityUtilities.CreateLocation(this.ArgumentType)); ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ArgumentLocationExpressionTypeMismatch(type2.FullName, expression.GetType().FullName), false, this.RuntimeArgument.Name, owner)); } break; default: return; } } }
public void Declare(LocationReference locationReference, Activity owner, ref IList <ValidationError> validationErrors) { Fx.Assert(locationReference != null, "Must not be null"); if (locationReference.Name == null) { if (this.unnamedDeclarations == null) { this.unnamedDeclarations = new List <LocationReference>(); } this.unnamedDeclarations.Add(locationReference); } else { if (this.Declarations.ContainsKey(locationReference.Name)) { string id = null; if (owner != null) { id = owner.Id; } ValidationError validationError = new ValidationError(SR.SymbolNamesMustBeUnique(locationReference.Name)) { Source = owner, Id = id }; ActivityUtilities.Add(ref validationErrors, validationError); } else { this.Declarations.Add(locationReference.Name, locationReference); } } }
internal bool InitializeRelationship(Activity parent, ActivityCollectionType collectionType, ref IList <ValidationError> validationErrors) { if (this.cacheId == parent.CacheId) { Activity owner = parent.MemberOf.Owner; if (owner == null) { Activity activity2 = this.Handler; if (activity2 == null) { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ActivityDelegateCannotBeReferencedWithoutTargetNoHandler(parent.DisplayName, this.owner.DisplayName), false, parent)); } else { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ActivityDelegateCannotBeReferencedWithoutTarget(activity2.DisplayName, parent.DisplayName, this.owner.DisplayName), false, parent)); } return(false); } if (owner.Delegates.Contains(this) || owner.ImportedDelegates.Contains(this)) { return(true); } Activity handler = this.Handler; if (handler == null) { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ActivityDelegateCannotBeReferencedNoHandler(parent.DisplayName, owner.DisplayName, this.owner.DisplayName), false, parent)); } else { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ActivityDelegateCannotBeReferenced(handler.DisplayName, parent.DisplayName, owner.DisplayName, this.owner.DisplayName), false, parent)); } return(false); } this.owner = parent; this.cacheId = parent.CacheId; this.parentCollectionType = collectionType; this.InternalCacheMetadata(); LocationReferenceEnvironment implementationEnvironment = null; if (collectionType == ActivityCollectionType.Implementation) { implementationEnvironment = parent.ImplementationEnvironment; } else { implementationEnvironment = parent.PublicEnvironment; } if (this.RuntimeDelegateArguments.Count > 0) { ActivityLocationReferenceEnvironment environment2 = new ActivityLocationReferenceEnvironment(implementationEnvironment); implementationEnvironment = environment2; for (int i = 0; i < this.RuntimeDelegateArguments.Count; i++) { RuntimeDelegateArgument argument = this.RuntimeDelegateArguments[i]; DelegateArgument boundArgument = argument.BoundArgument; if (boundArgument != null) { if (boundArgument.Direction != argument.Direction) { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.RuntimeDelegateArgumentDirectionIncorrect, parent)); } if (boundArgument.Type != argument.Type) { ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.RuntimeDelegateArgumentTypeIncorrect, parent)); } environment2.Declare(boundArgument, this.owner, ref validationErrors); } } } this.Environment = implementationEnvironment; if (this.Handler != null) { return(this.Handler.InitializeRelationship(this, collectionType, ref validationErrors)); } return(true); }
/// <summary> /// Initializes the relationship. /// </summary> /// <param name="parent">The parent.</param> /// <param name="collectionType">Type of the collection.</param> /// <param name="validationErrors">The validation errors.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns> 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. var referenceTarget = parent.MemberOf.Owner; if (referenceTarget == null) { var 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)) { var 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; this.InternalCacheMetadata(); // We need to setup the delegate environment so that it is available when we process the Handler. var delegateEnvironment = collectionType == ActivityCollectionType.Implementation ? parent.ImplementationEnvironment : parent.PublicEnvironment; if (this.RuntimeDelegateArguments.Count > 0) { var newEnvironment = new ActivityLocationReferenceEnvironment(delegateEnvironment); delegateEnvironment = newEnvironment; for (var argumentIndex = 0; argumentIndex < this.RuntimeDelegateArguments.Count; argumentIndex++) { var runtimeDelegateArgument = this.RuntimeDelegateArguments[argumentIndex]; var 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; return(this.Handler == null ? true : this.Handler.InitializeRelationship(this, collectionType, ref validationErrors)); }