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.
}
}
}