internal override void CacheMetadata(ActivityMetadata metadata, Activity owner, string operationName) { // force a shred for every CacheMetadata call ShredParameters(); int index = 0; foreach (Type argumentType in this.argumentTypes) { if (argumentType == null || argumentType == TypeHelper.VoidType) { metadata.AddValidationError(SR.ArgumentCannotHaveNullOrVoidType(owner.DisplayName, argumentNames[index])); } if (argumentType == MessageDescription.TypeOfUntypedMessage || MessageBuilder.IsMessageContract(argumentType)) { metadata.AddValidationError(SR.ReceiveParametersContentDoesNotSupportMessage(owner.DisplayName, argumentNames[index])); } index++; } if (!metadata.HasViolations) { foreach (KeyValuePair <string, OutArgument> pair in this.Parameters) { RuntimeArgument newRuntimeArgument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, ArgumentDirection.Out); metadata.Bind(pair.Value, newRuntimeArgument); metadata.AddArgument(newRuntimeArgument); } } }
internal override void CacheMetadata(ActivityMetadata metadata, Activity owner, string operationName) { this.ShredParameters(); int index = 0; foreach (Type type in this.argumentTypes) { if ((type == null) || (type == TypeHelper.VoidType)) { metadata.AddValidationError(System.ServiceModel.Activities.SR.ArgumentCannotHaveNullOrVoidType(owner.DisplayName, this.argumentNames[index])); } if ((type == MessageDescription.TypeOfUntypedMessage) || MessageBuilder.IsMessageContract(type)) { metadata.AddValidationError(System.ServiceModel.Activities.SR.SendParametersContentDoesNotSupportMessage(owner.DisplayName, this.argumentNames[index])); } index++; } if (!metadata.HasViolations) { foreach (KeyValuePair <string, InArgument> pair in this.Parameters) { RuntimeArgument argument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, ArgumentDirection.In); metadata.Bind(pair.Value, argument); metadata.AddArgument(argument); } } }
internal override void ConfigureInternalReceiveReply(InternalReceiveMessage internalReceiveMessage, out FromReply responseFormatter) { if (this.InternalDeclaredMessageType == MessageDescription.TypeOfUntypedMessage) { internalReceiveMessage.Message = new OutArgument <System.ServiceModel.Channels.Message>(context => ((OutArgument <System.ServiceModel.Channels.Message>) this.Message).Get(context)); responseFormatter = null; } else { responseFormatter = new FromReply(); if (MessageBuilder.IsMessageContract(this.InternalDeclaredMessageType)) { responseFormatter.Result = OutArgument.CreateReference(this.Message, "Message"); } else if (this.Message != null) { responseFormatter.Parameters.Add(OutArgument.CreateReference(this.Message, "Message")); } } }
internal override void ConfigureInternalSendReply(InternalSendMessage internalSendMessage, out ToReply responseFormatter) { if (this.InternalDeclaredMessageType == MessageDescription.TypeOfUntypedMessage) { internalSendMessage.Message = new InArgument <Message>(context => ((InArgument <Message>) this.Message).Get(context)); responseFormatter = null; } else { responseFormatter = new ToReply(); // WCF rule dictates that MessageContract must be bound to ReturnValue, not Parameters if (MessageBuilder.IsMessageContract(this.InternalDeclaredMessageType)) { responseFormatter.Result = InArgument.CreateReference(this.Message, "Message"); } else if (this.Message != null) { responseFormatter.Parameters.Add(InArgument.CreateReference(this.Message, "Message")); } } }
protected override void CacheMetadata(ActivityMetadata metadata) { if (string.IsNullOrEmpty(this.OperationName)) { metadata.AddValidationError(System.ServiceModel.Activities.SR.MissingOperationName(base.DisplayName)); } if (this.ServiceContractName == null) { string errorMessageOperationName = ContractValidationHelper.GetErrorMessageOperationName(this.OperationName); metadata.AddValidationError(System.ServiceModel.Activities.SR.MissingServiceContractName(base.DisplayName, errorMessageOperationName)); } if (this.Endpoint == null) { if (string.IsNullOrEmpty(this.EndpointConfigurationName)) { metadata.AddValidationError(System.ServiceModel.Activities.SR.EndpointNotSet(base.DisplayName, this.OperationName)); } } else { if (!string.IsNullOrEmpty(this.EndpointConfigurationName)) { metadata.AddValidationError(System.ServiceModel.Activities.SR.EndpointIncorrectlySet(base.DisplayName, this.OperationName)); } if (this.Endpoint.Binding == null) { metadata.AddValidationError(System.ServiceModel.Activities.SR.MissingBindingInEndpoint(this.Endpoint.Name, this.ServiceContractName)); } } MessagingActivityHelper.ValidateCorrelationInitializer(metadata, this.correlationInitializers, false, base.DisplayName, this.OperationName); MessagingActivityHelper.AddRuntimeArgument(this.CorrelatesWith, "CorrelatesWith", System.ServiceModel.Activities.Constants.CorrelationHandleType, ArgumentDirection.In, metadata); MessagingActivityHelper.AddRuntimeArgument(this.EndpointAddress, "EndpointAddress", System.ServiceModel.Activities.Constants.UriType, ArgumentDirection.In, metadata); this.InternalContent.CacheMetadata(metadata, this, this.OperationName); if (this.correlationInitializers != null) { for (int i = 0; i < this.correlationInitializers.Count; i++) { CorrelationInitializer initializer = this.correlationInitializers[i]; initializer.ArgumentName = "Parameter" + i; RuntimeArgument argument = new RuntimeArgument(initializer.ArgumentName, System.ServiceModel.Activities.Constants.CorrelationHandleType, ArgumentDirection.In); metadata.Bind(initializer.CorrelationHandle, argument); metadata.AddArgument(argument); } } if (!metadata.HasViolations) { if ((this.InternalContent is SendMessageContent) && MessageBuilder.IsMessageContract(((SendMessageContent)this.InternalContent).InternalDeclaredMessageType)) { this.OperationUsesMessageContract = true; } this.internalSend = this.CreateInternalSend(); this.InternalContent.ConfigureInternalSend(this.internalSend, out this.requestFormatter); if ((this.requestFormatter != null) && (this.lazyFormatter != null)) { this.requestFormatter.Formatter = this.lazyFormatter; } } else { this.internalSend = null; this.requestFormatter = null; } }
protected override void CacheMetadata(ActivityMetadata metadata) { if (this.Request == null) { metadata.AddValidationError(SR.ReceiveReplyRequestCannotBeNull(this.DisplayName)); } else { // Need to validate Send.ServiceContractName and Send.OperationName here so that we can proceed with contract inference if (this.Request.ServiceContractName == null) { string errorOperationName = ContractValidationHelper.GetErrorMessageOperationName(this.Request.OperationName); metadata.AddValidationError(SR.MissingServiceContractName(this.Request.DisplayName, errorOperationName)); } if (string.IsNullOrEmpty(this.Request.OperationName)) { metadata.AddValidationError(SR.MissingOperationName(this.Request.DisplayName)); } } // validate Correlation Initializers MessagingActivityHelper.ValidateCorrelationInitializer(metadata, this.correlationInitializers, true, this.DisplayName, (this.Request != null ? this.Request.OperationName : String.Empty)); // Validate Content string operationName = this.Request != null ? this.Request.OperationName : null; this.InternalContent.CacheMetadata(metadata, this, operationName); if (this.correlationInitializers != null) { for (int i = 0; i < this.correlationInitializers.Count; i++) { CorrelationInitializer initializer = this.correlationInitializers[i]; initializer.ArgumentName = Constants.Parameter + i; RuntimeArgument initializerArgument = new RuntimeArgument(initializer.ArgumentName, Constants.CorrelationHandleType, ArgumentDirection.In); metadata.Bind(initializer.CorrelationHandle, initializerArgument); metadata.AddArgument(initializerArgument); } } if (!metadata.HasViolations) { this.internalReceive = CreateInternalReceive(); InArgument <CorrelationHandle> requestReplyHandleFromSend = GetReplyHandleFromSend(); if (requestReplyHandleFromSend != null) { InArgument <CorrelationHandle> resultCorrelatesWith = MessagingActivityHelper.CreateReplyCorrelatesWith(requestReplyHandleFromSend); RuntimeArgument resultCorrelatesWithArgument = new RuntimeArgument("ResultCorrelatesWith", Constants.CorrelationHandleType, ArgumentDirection.In); metadata.Bind(resultCorrelatesWith, resultCorrelatesWithArgument); metadata.AddArgument(resultCorrelatesWithArgument); this.internalReceive.CorrelatesWith = (InArgument <CorrelationHandle>)InArgument.CreateReference(resultCorrelatesWith, "ResultCorrelatesWith"); } this.InternalContent.ConfigureInternalReceiveReply(this.internalReceive, out this.responseFormatter); if (this.InternalContent is ReceiveMessageContent && MessageBuilder.IsMessageContract(((ReceiveMessageContent)this.InternalContent).InternalDeclaredMessageType)) { this.Request.OperationUsesMessageContract = true; } OperationDescription operation = ContractInferenceHelper.CreateTwoWayOperationDescription(this.Request, this); this.Request.OperationDescription = operation; if (this.responseFormatter != null) { IClientMessageFormatter formatter = ClientOperationFormatterProvider.GetFormatterFromRuntime(operation); this.Request.SetFormatter(formatter); this.responseFormatter.Formatter = formatter; // int index = 0; Type[] faultTypes = new Type[operation.KnownTypes.Count]; foreach (Type type in operation.KnownTypes) { faultTypes[index] = type; index++; } this.responseFormatter.FaultFormatter = new FaultFormatter(faultTypes); } // Add CorrelationQuery to the Send->ReplyCorrelation, we validate that the same query is not added multiple times if (this.correlationInitializers != null && this.correlationInitializers.Count > 0) { Collection <CorrelationQuery> internalCorrelationQueryCollection = ContractInferenceHelper.CreateClientCorrelationQueries(null, this.correlationInitializers, this.Action, this.Request.ServiceContractName, this.Request.OperationName, true); foreach (CorrelationQuery query in internalCorrelationQueryCollection) { this.Request.SetReplyCorrelationQuery(query); } } } else { this.internalReceive = null; this.responseFormatter = null; } // We don't have any imported children despite referencing the Request metadata.SetImportedChildrenCollection(new Collection <Activity>()); }
protected override void CacheMetadata(ActivityMetadata metadata) { if (this.Request == null) { metadata.AddValidationError(System.ServiceModel.Activities.SR.ReceiveReplyRequestCannotBeNull(base.DisplayName)); } else { if (this.Request.ServiceContractName == null) { string errorMessageOperationName = ContractValidationHelper.GetErrorMessageOperationName(this.Request.OperationName); metadata.AddValidationError(System.ServiceModel.Activities.SR.MissingServiceContractName(this.Request.DisplayName, errorMessageOperationName)); } if (string.IsNullOrEmpty(this.Request.OperationName)) { metadata.AddValidationError(System.ServiceModel.Activities.SR.MissingOperationName(this.Request.DisplayName)); } } MessagingActivityHelper.ValidateCorrelationInitializer(metadata, this.correlationInitializers, true, base.DisplayName, (this.Request != null) ? this.Request.OperationName : string.Empty); string operationName = (this.Request != null) ? this.Request.OperationName : null; this.InternalContent.CacheMetadata(metadata, this, operationName); if (this.correlationInitializers != null) { for (int i = 0; i < this.correlationInitializers.Count; i++) { CorrelationInitializer initializer = this.correlationInitializers[i]; initializer.ArgumentName = "Parameter" + i; RuntimeArgument argument = new RuntimeArgument(initializer.ArgumentName, Constants.CorrelationHandleType, ArgumentDirection.In); metadata.Bind(initializer.CorrelationHandle, argument); metadata.AddArgument(argument); } } if (!metadata.HasViolations) { this.internalReceive = this.CreateInternalReceive(); InArgument <CorrelationHandle> replyHandleFromSend = this.GetReplyHandleFromSend(); if (replyHandleFromSend != null) { InArgument <CorrelationHandle> binding = MessagingActivityHelper.CreateReplyCorrelatesWith(replyHandleFromSend); RuntimeArgument argument4 = new RuntimeArgument("ResultCorrelatesWith", Constants.CorrelationHandleType, ArgumentDirection.In); metadata.Bind(binding, argument4); metadata.AddArgument(argument4); this.internalReceive.CorrelatesWith = (InArgument <CorrelationHandle>)InArgument.CreateReference(binding, "ResultCorrelatesWith"); } this.InternalContent.ConfigureInternalReceiveReply(this.internalReceive, out this.responseFormatter); if ((this.InternalContent is ReceiveMessageContent) && MessageBuilder.IsMessageContract(((ReceiveMessageContent)this.InternalContent).InternalDeclaredMessageType)) { this.Request.OperationUsesMessageContract = true; } OperationDescription operationDescription = ContractInferenceHelper.CreateTwoWayOperationDescription(this.Request, this); this.Request.OperationDescription = operationDescription; if (this.responseFormatter != null) { IClientMessageFormatter formatterFromRuntime = ClientOperationFormatterProvider.GetFormatterFromRuntime(operationDescription); this.Request.SetFormatter(formatterFromRuntime); this.responseFormatter.Formatter = formatterFromRuntime; int index = 0; Type[] detailTypes = new Type[operationDescription.KnownTypes.Count]; foreach (Type type in operationDescription.KnownTypes) { detailTypes[index] = type; index++; } this.responseFormatter.FaultFormatter = new FaultFormatter(detailTypes); } if ((this.correlationInitializers != null) && (this.correlationInitializers.Count > 0)) { foreach (CorrelationQuery query in ContractInferenceHelper.CreateClientCorrelationQueries(null, this.correlationInitializers, this.Action, this.Request.ServiceContractName, this.Request.OperationName, true)) { this.Request.SetReplyCorrelationQuery(query); } } } else { this.internalReceive = null; this.responseFormatter = null; } metadata.SetImportedChildrenCollection(new Collection <Activity>()); }
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. } } }