protected override void OnExecute(NativeActivityContext context, object objectToValidate, ValidationContext objectToValidateContext) { bool foundMultiple; ActivityWithResult boundExpression; LocationReference locationReference; ActivityWithResult activity = (ActivityWithResult)objectToValidate; foreach (RuntimeArgument runtimeArgument in activity.RuntimeArguments) { boundExpression = runtimeArgument.BoundArgument.Expression; if (boundExpression != null && boundExpression is ILocationReferenceWrapper) { locationReference = ((ILocationReferenceWrapper)boundExpression).LocationReference; if (locationReference != null) { foundMultiple = FindLocationReferencesFromEnvironment(objectToValidateContext.Environment, locationReference.Name); if (foundMultiple) { Constraint.AddValidationError(context, new ValidationError(SR.AmbiguousVBVariableReference(locationReference.Name))); } } } } }
protected override void Execute(NativeActivityContext context) { IEnumerable <Activity> enumerable = this.ParentChain.Get(context); Rethrow rethrow = this.RethrowActivity.Get(context); Activity item = rethrow; bool flag = false; foreach (Activity activity2 in enumerable) { if (activity2.ImplementationChildren.Contains(item)) { flag = true; } TryCatch @catch = activity2 as TryCatch; if ((@catch != null) && (item != null)) { foreach (Catch catch2 in @catch.Catches) { ActivityDelegate action = catch2.GetAction(); if ((action != null) && (action.Handler == item)) { if (flag) { Constraint.AddValidationError(context, new ValidationError(System.Activities.SR.RethrowMustBeAPublicChild(rethrow.DisplayName), rethrow)); } return; } } } item = activity2; } Constraint.AddValidationError(context, new ValidationError(System.Activities.SR.RethrowNotInATryCatch(rethrow.DisplayName), rethrow)); }
internal override void ValidateContract(NativeActivityContext context, OperationDescription targetOperation, object owner, MessageDirection direction) { MessageDescription targetMessage; string overridingAction; bool isResponse; SerializerOption serializerOption; if (direction == MessageDirection.Input) { Fx.Assert(targetOperation.Messages.Count >= 1, "There must be at least one MessageDescription in an OperationDescription!"); targetMessage = targetOperation.Messages[0]; Send send = owner as Send; Fx.Assert(send != null, "The parent of a SendMessageContent with in-message can only be Send!"); overridingAction = send.Action; serializerOption = send.SerializerOption; isResponse = false; } else { Fx.Assert(targetOperation.Messages.Count == 2, "There must be exactly two MessageDescription objects for a two-way operation!"); targetMessage = targetOperation.Messages[1]; SendReply sendReply = owner as SendReply; Fx.Assert(sendReply != null, "The parent of a SendMessageContent with out-message can only be SendReply!"); Fx.Assert(sendReply.Request != null, "SendReply.Request should not be null by now!"); overridingAction = sendReply.Action; serializerOption = sendReply.Request.SerializerOption; isResponse = true; } if (!this.IsFault) { ContractValidationHelper.ValidateAction(context, targetMessage, overridingAction, targetOperation, isResponse); if (ContractValidationHelper.IsSendParameterContent(targetOperation)) { Constraint.AddValidationError(context, new ValidationError(SR.MisuseOfMessageContent(targetOperation.Name, targetOperation.DeclaringContract.Name))); } else { ContractValidationHelper.ValidateMessageContent(context, targetMessage, this.InternalDeclaredMessageType, serializerOption, targetOperation, isResponse); } } else { Fx.Assert(this.InternalDeclaredMessageType != null, "IsFault returns true only when argument is of exception type!"); Type argumentType = this.InternalDeclaredMessageType; if (argumentType.IsGenericType && argumentType.GetGenericTypeDefinition() == ContractInferenceHelper.FaultExceptionType) { Type faultType = argumentType.GetGenericArguments()[0]; ContractValidationHelper.ValidateFault(context, targetOperation, overridingAction, faultType); } } }
public static void ValidateAction(NativeActivityContext context, MessageDescription targetMessage, string overridingAction, OperationDescription targetOperation, bool isResponse) { if (overridingAction == null && targetMessage.Action != NamingHelper.GetMessageAction(targetOperation, isResponse) || overridingAction != null && overridingAction != targetMessage.Action) { Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(overridingAction, "Action", targetMessage.Action, targetOperation.Name, targetOperation.DeclaringContract.Name))); } }
protected override void Execute(NativeActivityContext context) { IEnumerable <Activity> parentChain = this.ParentChain.Get(context); Rethrow rethrowActivity = this.RethrowActivity.Get(context); Activity previousActivity = rethrowActivity; bool privateRethrow = false; // TryCatch with Rethrow is usually authored in the following way: // // TryCatch // { // Try = DoWork // Catch Handler = Sequence // { // ProcessException, // Rethrow // } // } // Notice that the chain of Activities is TryCatch->Sequence->Rethrow // We want to validate that Rethrow is in the catch block of TryCatch // We walk up the parent chain until we find TryCatch. Then we check if one the catch handlers points to Sequence(the previous activity in the tree) foreach (Activity parent in parentChain) { // Rethrow is only allowed under the public children of a TryCatch activity. // If any of the activities in the tree is a private child, report a constraint violation. if (parent.ImplementationChildren.Contains(previousActivity)) { privateRethrow = true; } TryCatch tryCatch = parent as TryCatch; if (tryCatch != null) { if (previousActivity != null) { foreach (Catch catchHandler in tryCatch.Catches) { ActivityDelegate catchAction = catchHandler.GetAction(); if (catchAction != null && catchAction.Handler == previousActivity) { if (privateRethrow) { Constraint.AddValidationError(context, new ValidationError(SR.RethrowMustBeAPublicChild(rethrowActivity.DisplayName), rethrowActivity)); } return; } } } } previousActivity = parent; } Constraint.AddValidationError(context, new ValidationError(SR.RethrowNotInATryCatch(rethrowActivity.DisplayName), rethrowActivity)); }
internal override void ValidateContract(NativeActivityContext context, OperationDescription targetOperation, object owner, MessageDirection direction) { MessageDescription targetMessage; string overridingAction; bool isResponse; if (direction == MessageDirection.Input) { Fx.Assert(targetOperation.Messages.Count >= 1, "There must be at least one MessageDescription in an OperationDescription!"); targetMessage = targetOperation.Messages[0]; Fx.Assert(owner is Send, "The parent of a SendParametersContent with in-message can only be Send!"); overridingAction = ((Send)owner).Action; isResponse = false; } else { Fx.Assert(targetOperation.Messages.Count == 2, "There must be exactly two MessageDescription objects for a two-way operation!"); targetMessage = targetOperation.Messages[1]; Fx.Assert(owner is SendReply, "The parent of a SendParametersContent with out-message can only be SendReply!"); overridingAction = ((SendReply)owner).Action; isResponse = true; } if (!this.IsFault) { ContractValidationHelper.ValidateAction(context, targetMessage, overridingAction, targetOperation, isResponse); if (ContractValidationHelper.IsSendParameterContent(targetOperation)) { ContractValidationHelper.ValidateParametersContent(context, targetMessage, (IDictionary)this.Parameters, targetOperation, isResponse); } else { Constraint.AddValidationError(context, new ValidationError(SR.MisuseOfParameterContent(targetOperation.Name, targetOperation.DeclaringContract.Name))); } } else { Fx.Assert(this.argumentTypes != null && this.argumentTypes.Length == 1, "Exception should be the only parameter in SendFault!"); Type argumentType = this.argumentTypes[0]; if (argumentType.IsGenericType && argumentType.GetGenericTypeDefinition() == ContractInferenceHelper.FaultExceptionType) { Type faultType = argumentType.GetGenericArguments()[0]; ContractValidationHelper.ValidateFault(context, targetOperation, overridingAction, faultType); } } }
internal override void ValidateContract(NativeActivityContext context, OperationDescription targetOperation, object owner, MessageDirection direction) { MessageDescription targetMessage; string overridingAction; bool isResponse; SerializerOption serializerOption; if (direction == MessageDirection.Input) { Fx.Assert(targetOperation.Messages.Count >= 1, "There must be at least one MessageDescription in an OperationDescription!"); targetMessage = targetOperation.Messages[0]; Receive receive = owner as Receive; Fx.Assert(receive != null, "The parent of a ReceiveMessageContent with in-message can only be Receive!"); overridingAction = receive.Action; serializerOption = receive.SerializerOption; isResponse = false; } else { Fx.Assert(targetOperation.Messages.Count == 2, "There must be exactly two MessageDescription objects for a two-way operation!"); targetMessage = targetOperation.Messages[1]; ReceiveReply receiveReply = owner as ReceiveReply; Fx.Assert(receiveReply != null, "The parent of a ReceiveMessageContent with out-message can only be ReceiveReply!"); Fx.Assert(receiveReply.Request != null, "ReceiveReply.Request should not be null by now!"); overridingAction = receiveReply.Action; serializerOption = receiveReply.Request.SerializerOption; isResponse = true; } ContractValidationHelper.ValidateAction(context, targetMessage, overridingAction, targetOperation, isResponse); if (ContractValidationHelper.IsReceiveParameterContent(targetOperation)) { Constraint.AddValidationError(context, new ValidationError(SR.MisuseOfMessageContent(targetOperation.Name, targetOperation.DeclaringContract.Name))); } else { ContractValidationHelper.ValidateMessageContent(context, targetMessage, this.InternalDeclaredMessageType, serializerOption, targetOperation, isResponse); } }
public static void ValidateFault(NativeActivityContext context, OperationDescription targetOperation, string overridingAction, Type faultType) { bool faultTypeExistOnContract = false; for (int index = 0; index < targetOperation.Faults.Count; index++) { FaultDescription targetFault = targetOperation.Faults[index]; if (targetFault.DetailType == faultType) { string name = NamingHelper.TypeName(faultType) + TypeLoader.FaultSuffix; string action = overridingAction ?? NamingHelper.GetMessageAction(targetOperation, false) + name; if (targetFault.Action != action) { Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(action, "Fault Action", targetFault.Action, targetOperation.Name, targetOperation.DeclaringContract.Name))); } if (targetFault.Name != NamingHelper.XmlName(name)) { Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(NamingHelper.XmlName(name), "Fault Name", targetFault.Name, targetOperation.Name, targetOperation.DeclaringContract.Name))); } if (targetFault.Namespace != targetOperation.DeclaringContract.Namespace) { Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(targetOperation.DeclaringContract.Namespace, "Fault Namespace", targetFault.Namespace, targetOperation.Name, targetOperation.DeclaringContract.Name))); } if (targetFault.HasProtectionLevel) { Constraint.AddValidationError(context, new ValidationError(SR2.ProtectionLevelNotSupported(targetOperation.Name, targetOperation.DeclaringContract.Name))); } // TypeLoader guarantees that fault types are unique in the Faults collection. faultTypeExistOnContract = true; break; } } // It is OK to have fewer fault types than defined on the contract. // But we do not allow workflow to define more fault types than specified on the contract. if (!faultTypeExistOnContract) { Constraint.AddValidationError(context, new ValidationError(SR2.FaultTypeMismatch(faultType.FullName, targetOperation.Name, targetOperation.DeclaringContract.Name))); } }
internal override void ValidateContract(NativeActivityContext context, OperationDescription targetOperation, object owner, MessageDirection direction) { MessageDescription targetMessage; string overridingAction; bool isResponse; if (direction == MessageDirection.Input) { Fx.Assert(targetOperation.Messages.Count >= 1, "There must be at least one MessageDescription in an OperationDescription!"); targetMessage = targetOperation.Messages[0]; Fx.Assert(owner is Receive, "The parent of a ReceiveParametersContent with in-message can only be Receive!"); overridingAction = ((Receive)owner).Action; isResponse = false; } else { Fx.Assert(targetOperation.Messages.Count == 2, "There must be exactly two MessageDescription objects for a two-way operation!"); targetMessage = targetOperation.Messages[1]; Fx.Assert(owner is ReceiveReply, "The parent of a ReceiveParametersContent with out-message can only be ReceiveReply!"); overridingAction = ((ReceiveReply)owner).Action; isResponse = true; } ContractValidationHelper.ValidateAction(context, targetMessage, overridingAction, targetOperation, isResponse); if (ContractValidationHelper.IsReceiveParameterContent(targetOperation)) { ContractValidationHelper.ValidateParametersContent(context, targetMessage, (IDictionary)this.Parameters, targetOperation, isResponse); } else { Constraint.AddValidationError(context, new ValidationError(SR.MisuseOfParameterContent(targetOperation.Name, targetOperation.DeclaringContract.Name))); } }
protected override void OnScopeValidationError(NativeActivityContext context) { Constraint.AddValidationError(context, new ValidationError(string.Format(Resources.ValidationScope_Error, nameof(Iterate)))); }
public static void ValidateParametersContent(NativeActivityContext context, MessageDescription targetMessage, IDictionary parameters, OperationDescription targetOperation, bool isResponse) { // The following properties can only be set via message contract. Therefore, we do not need to validate them here. // MessageDescription: Headers, Properties, ProtectionLevel // MessagePartDescription: Namespace, ProtectionLevel, Multiple, Index MessageBodyDescription targetMessageBody = targetMessage.Body; Fx.Assert(targetMessageBody != null, "MessageDescription.Body is never null!"); if (targetMessageBody.WrapperName == null) { Constraint.AddValidationError(context, new ValidationError(SR2.UnwrappedMessageNotSupported(targetOperation.Name, targetOperation.DeclaringContract.Name))); } if (targetMessageBody.WrapperNamespace == null) { Constraint.AddValidationError(context, new ValidationError(SR2.UnwrappedMessageNotSupported(targetOperation.Name, targetOperation.DeclaringContract.Name))); } IDictionaryEnumerator iterator = parameters.GetEnumerator(); int benchmarkIndex = 0; int hitCount = 0; // Return value needs to be treated specially since ReceiveParametersContent does not have return value on the OM. bool targetHasReturnValue = isResponse && targetMessageBody.ReturnValue != null && targetMessageBody.ReturnValue.Type != TypeHelper.VoidType; if (targetHasReturnValue) { if (iterator.MoveNext() && (string)iterator.Key == targetMessageBody.ReturnValue.Name) { Argument argument = (Argument)iterator.Value; if (argument != null && argument.ArgumentType != targetMessageBody.ReturnValue.Type) { Constraint.AddValidationError(context, new ValidationError(SR2.FirstParameterDoesnotMatchTheReturnValue(argument.ArgumentType.FullName, targetMessageBody.ReturnValue.Type.FullName, targetOperation.Name, targetOperation.DeclaringContract.Name))); } hitCount++; } else if (parameters.Contains(targetMessageBody.ReturnValue.Name)) { Constraint.AddValidationError(context, new ValidationError(SR2.ParameterPositionMismatch(targetMessageBody.ReturnValue.Name, targetOperation.Name, targetOperation.DeclaringContract.Name, "0"))); hitCount++; } else { Constraint.AddValidationError(context, new ValidationError(SR2.ReturnValueMissing(targetMessageBody.ReturnValue.Type.FullName, targetOperation.Name, targetOperation.DeclaringContract.Name))); } benchmarkIndex++; } foreach (MessagePartDescription targetPart in targetMessageBody.Parts) { if (iterator.MoveNext() && (string)iterator.Key == targetPart.Name) { Argument argument = (Argument)iterator.Value; if (argument != null && argument.ArgumentType != targetPart.Type) { Constraint.AddValidationError(context, new ValidationError(SR2.ParameterTypeMismatch(targetPart.Name, targetPart.Type.FullName, targetOperation.Name, targetOperation.DeclaringContract.Name))); } hitCount++; } else if (parameters.Contains(targetPart.Name)) { Constraint.AddValidationError(context, new ValidationError(SR2.ParameterPositionMismatch(targetPart.Name, targetOperation.Name, targetOperation.DeclaringContract.Name, benchmarkIndex))); hitCount++; } else { Constraint.AddValidationError(context, new ValidationError(SR2.MissingParameter(targetPart.Name, targetOperation.Name, targetOperation.DeclaringContract.Name))); } benchmarkIndex++; } if (hitCount != parameters.Count) { foreach (string name in parameters.Keys) { XmlQualifiedName qName = new XmlQualifiedName(name, targetOperation.DeclaringContract.Namespace); if (!targetMessageBody.Parts.Contains(qName)) { if (!targetHasReturnValue || targetHasReturnValue && name != targetMessageBody.ReturnValue.Name) { Constraint.AddValidationError(context, new ValidationError(SR2.ExtraParameter(name, targetOperation.Name, targetOperation.DeclaringContract.Name))); } } } } }
public static void ValidateMessageContent(NativeActivityContext context, MessageDescription targetMessage, Type declaredMessageType, SerializerOption serializerOption, OperationDescription operation, bool isResponse) { // MessageContract is allowed only if the WCF contract interface specifies the same message contract type. if (MessageBuilder.IsMessageContract(declaredMessageType)) { // if it is a typed message contract, we just validate the type of the message matches if (targetMessage.MessageType != null) { if (declaredMessageType != targetMessage.MessageType) { Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(declaredMessageType.ToString(), "type", targetMessage.MessageType.ToString(), operation.Name, operation.DeclaringContract.Name))); } } else { Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(declaredMessageType.ToString(), "type", "null", operation.Name, operation.DeclaringContract.Name))); } return; } else if (declaredMessageType != null && declaredMessageType.IsAssignableFrom(typeof(System.ServiceModel.Channels.Message))) { //This is an untyped message contract if (targetMessage.Body == null) { Constraint.AddValidationError(context, new ValidationError(SR2.BodyCannotBeNull)); } else { if (isResponse) { if (targetMessage.Body.ReturnValue == null) { Constraint.AddValidationError(context, new ValidationError(SR2.ExtraReturnValue)); } else if (!targetMessage.Body.ReturnValue.Type.IsAssignableFrom(typeof(System.ServiceModel.Channels.Message))) { Constraint.AddValidationError(context, new ValidationError(SR2.FirstParameterDoesnotMatchTheReturnValue(declaredMessageType.FullName, targetMessage.Body.ReturnValue.Type.Name, operation.Name, operation.DeclaringContract.Name))); } } else { if (targetMessage.Body.Parts.Count == 0) { Constraint.AddValidationError(context, new ValidationError(SR2.ParameterNumberMismatch(declaredMessageType.FullName, operation.Name, operation.DeclaringContract.Name))); } else if (targetMessage.Body.Parts.Count > 1) { Constraint.AddValidationError(context, new ValidationError(SR2.MessageContentCannotHaveMoreThanOneParameter(operation.Name, operation.DeclaringContract.Name))); } else { if (!targetMessage.Body.Parts[0].Type.IsAssignableFrom(typeof(System.ServiceModel.Channels.Message))) { Constraint.AddValidationError(context, new ValidationError(SR2.MessageTypeMismatch(targetMessage.Body.Parts[0].Type.FullName, operation.Name, operation.DeclaringContract.Name))); } } } } return; } // In case the WCF contract is a typed message, and the Receive activity also uses ReceiveMessageContent to infer a typed message, the contract needs to be matched Fx.Assert(targetMessage.Body != null, "MessageDescription.Body is never null!"); // MessageDescription: Headers, Properties, ProtectionLevel // MessageBodyDescription: ReturnValue, WrapperName, WrapperNamespace // MessagePartDescription: Name, Namespace, Type, ProtectionLevel, Multiple, Index if (targetMessage.Headers.Count > 0) { Constraint.AddValidationError(context, new ValidationError(SR2.MessageHeaderNotSupported(operation.Name, operation.DeclaringContract.Name))); } if (targetMessage.Properties.Count > 0) { Constraint.AddValidationError(context, new ValidationError(SR2.MessagePropertyIsNotSupported(operation.Name, operation.DeclaringContract.Name))); } if (targetMessage.HasProtectionLevel) { Constraint.AddValidationError(context, new ValidationError(SR2.ProtectionLevelIsNotSupported(operation.Name, operation.DeclaringContract.Name))); } if (declaredMessageType == null || declaredMessageType == TypeHelper.VoidType) { if (!targetMessage.IsVoid) { Constraint.AddValidationError(context, new ValidationError(SR2.MessageCannotBeEmpty(operation.Name, operation.DeclaringContract.Name))); } } else { string partName; string partNamespace; if (serializerOption == SerializerOption.DataContractSerializer) { XmlQualifiedName xmlQualifiedName = MessageBuilder.XsdDataContractExporter.GetRootElementName(declaredMessageType); if (xmlQualifiedName == null) { xmlQualifiedName = MessageBuilder.XsdDataContractExporter.GetSchemaTypeName(declaredMessageType); } if (!xmlQualifiedName.IsEmpty) { partName = xmlQualifiedName.Name; partNamespace = xmlQualifiedName.Namespace; } else { // For anonymous type, we assign CLR type name and contract namespace to MessagePartDescription partName = declaredMessageType.Name; partNamespace = operation.DeclaringContract.Namespace; } } else { XmlTypeMapping xmlTypeMapping = MessageBuilder.XmlReflectionImporter.ImportTypeMapping(declaredMessageType); partName = xmlTypeMapping.ElementName; partNamespace = xmlTypeMapping.Namespace; } MessagePartDescription targetPart = null; if (isResponse && targetMessage.Body.ReturnValue != null && targetMessage.Body.ReturnValue.Type != TypeHelper.VoidType) { if (targetMessage.Body.Parts.Count > 0) { Constraint.AddValidationError(context, new ValidationError(SR2.NotSupportMoreThanOneParametersInMessageContract(operation.Name, operation.DeclaringContract.Name))); } targetPart = targetMessage.Body.ReturnValue; } else if (!isResponse) { if (targetMessage.Body.WrapperName != null && targetMessage.Body.WrapperName != String.Empty) { Constraint.AddValidationError(context, new ValidationError(SR2.WrapperNotSupportedInMessageContract(operation.Name, operation.DeclaringContract.Name))); } if (targetMessage.Body.WrapperNamespace != null && targetMessage.Body.WrapperNamespace != String.Empty) { Constraint.AddValidationError(context, new ValidationError(SR2.WrapperNotSupportedInMessageContract(operation.Name, operation.DeclaringContract.Name))); } if (targetMessage.Body.Parts.Count == 0) { Constraint.AddValidationError(context, new ValidationError(SR2.ParameterNumberMismatch(declaredMessageType.FullName, operation.Name, operation.DeclaringContract.Name))); } else if (targetMessage.Body.Parts.Count > 1) { Constraint.AddValidationError(context, new ValidationError(SR2.MessageContentCannotHaveMoreThanOneParameter(operation.Name, operation.DeclaringContract.Name))); } else { targetPart = targetMessage.Body.Parts[0]; } } if (targetPart != null) { if (partName != targetPart.Name) { Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(partName, "parameter name", targetPart.Name, operation.Name, operation.DeclaringContract.Name))); } if (partNamespace != targetPart.Namespace) { Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(partNamespace, "parameter namespace", targetPart.Namespace, operation.Name, operation.DeclaringContract.Name))); } if (declaredMessageType != targetPart.Type) { if (declaredMessageType != null) { Constraint.AddValidationError(context, new ValidationError(SR2.ParameterTypeMismatch(declaredMessageType.FullName, targetPart.Type.FullName, operation.Name, operation.DeclaringContract.Name))); } else { Constraint.AddValidationError(context, new ValidationError(SR2.ParameterTypeMismatch(TypeHelper.VoidType.FullName, targetPart.Type.FullName, operation.Name, operation.DeclaringContract.Name))); } } if (targetPart.HasProtectionLevel) { Constraint.AddValidationError(context, new ValidationError(SR2.ProtectionLevelIsNotSupported(operation.Name, operation.DeclaringContract.Name))); } // Multiple and Index do not need to be validate because there is only one part in the message. } } }