internal override void InferMessageDescription(OperationDescription operation, object owner, MessageDirection direction)
{
ContractInferenceHelper.CheckForDisposableParameters(operation, this.InternalDeclaredMessageType);
string overridingAction = null;
SerializerOption dataContractSerializer = SerializerOption.DataContractSerializer;
Receive receive = owner as Receive;
if (receive != null)
{
overridingAction = receive.Action;
dataContractSerializer = receive.SerializerOption;
}
else
{
ReceiveReply reply = owner as ReceiveReply;
overridingAction = reply.Action;
dataContractSerializer = reply.Request.SerializerOption;
}
if (direction == MessageDirection.Input)
{
ContractInferenceHelper.AddInputMessage(operation, overridingAction, this.InternalDeclaredMessageType, dataContractSerializer);
}
else
{
ContractInferenceHelper.AddOutputMessage(operation, overridingAction, this.InternalDeclaredMessageType, dataContractSerializer);
}
}
private static void EmitStringSerialize(ILGenerator il, FieldInfo field, SerializerOption option)
{
EmitEncoding(il, field);
MethodInfo method = option == SerializerOption.Normal ? s_WriteValueStringWithIndexMethod : s_WriteValueStringMethod;
il.Emit(OpCodes.Call, method);
}
internal override void InferMessageDescription(OperationDescription operation, object owner, MessageDirection direction)
{
ContractInferenceHelper.CheckForDisposableParameters(operation, this.InternalDeclaredMessageType);
string overridingAction = null;
SerializerOption serializerOption = SerializerOption.DataContractSerializer;
Send send = owner as Send;
if (send != null)
{
overridingAction = send.Action;
serializerOption = send.SerializerOption;
}
else
{
SendReply sendReply = owner as SendReply;
Fx.Assert(sendReply != null, "The owner of SendMessageContent can only be Send or SendReply!");
overridingAction = sendReply.Action;
serializerOption = sendReply.Request.SerializerOption;
}
if (direction == MessageDirection.Input)
{
ContractInferenceHelper.AddInputMessage(operation, overridingAction, this.InternalDeclaredMessageType, serializerOption);
}
else
{
ContractInferenceHelper.AddOutputMessage(operation, overridingAction, this.InternalDeclaredMessageType, serializerOption);
}
}
private static void EmitComplexDeserialize(ILGenerator il, Type type, SerializerOption option)
{
if (option == SerializerOption.CompactLayout)
{
il.Emit(OpCodes.Call, s_IteratorNextAsComplexWithoutTagMethod.MakeGenericMethod(type));
}
else
{
il.Emit(OpCodes.Call, s_IteratorNextAsComplexMethod.MakeGenericMethod(type));
}
}
static void AddSerializerProvider(OperationDescription operation, SerializerOption serializerOption)
{
switch (serializerOption)
{
case SerializerOption.DataContractSerializer:
AddDataContractSerializerFormat(operation);
break;
case SerializerOption.XmlSerializer:
AddXmlSerializerFormat(operation);
break;
}
}
private static void EmitComplexSerialize(ILGenerator il, Type type, SerializerOption option)
{
MethodInfo method;
if (option == SerializerOption.Normal)
{
method = s_WriteValueComplexWithIndexMethod.MakeGenericMethod(type);
}
else
{
method = s_WriteValueComplexTypesMethod.MakeGenericMethod(type);
}
il.Emit(OpCodes.Call, method);
}
private static void EmitFloatSerialize(ILGenerator il, Type type, SerializerOption option)
{
MethodInfo method;
if (option == SerializerOption.Normal)
{
s_WriteValueFloatWithIndexTypes[1] = type;
method = s_WriterType.GetMethod(Resources.WriteValueMethodName, s_WriteValueFloatWithIndexTypes);
}
else
{
s_WriteValueFloatTypes[0] = type;
method = s_WriterType.GetMethod(Resources.WriteValueMethodName, s_WriteValueFloatTypes);
}
il.Emit(OpCodes.Call, method);
}
public static MessageDescription CreateMessageDescription(OperationDescription operation, bool isResponse,
MessageDirection direction, string overridingAction, Type type, SerializerOption serializerOption)
{
MessageDescription result;
if (type != null && IsMessageContract(type))
{
result = CreateFromMessageContract(operation, isResponse, direction, overridingAction, type);
}
else
{
// For Send/Receive, we do not wrap message
result = CreateEmptyMessageDescription(operation, isResponse, direction, overridingAction);
AddMessagePartDescription(operation, isResponse, result, type, serializerOption);
}
return result;
}
internal static Type InjectType <T>()
{
Type objType = typeof(T);
Type interfaceType = typeof(ITypeSerializer <T>);
TypeBuilder builder = CreateBuilder(objType, interfaceType);
GetSerializedFields(objType);
GetMessageCallbacks(objType);
SerializerOption option = objType.GetCustomAttribute <CompactLayoutAttribute>(true) == null
? SerializerOption.Normal : SerializerOption.CompactLayout;
for (int i = 0; i < s_Progress.Length; i++)
{
s_Progress[i].Execute(objType, interfaceType, builder, s_FieldData, s_MethodData, option);
}
return(builder.CreateType());
}
public static void AddMessagePartDescription(OperationDescription operation, bool isResponse, MessageDescription message, Type type, SerializerOption serializerOption)
{
if (type != null)
{
string name;
string str2;
if (serializerOption == SerializerOption.DataContractSerializer)
{
XmlQualifiedName rootElementName = XsdDataContractExporter.GetRootElementName(type);
if (rootElementName == null)
{
rootElementName = XsdDataContractExporter.GetSchemaTypeName(type);
}
if (!rootElementName.IsEmpty)
{
name = rootElementName.Name;
str2 = rootElementName.Namespace;
}
else
{
name = type.Name;
str2 = operation.DeclaringContract.Namespace;
}
}
else
{
XmlTypeMapping mapping = XmlReflectionImporter.ImportTypeMapping(type);
name = mapping.ElementName;
str2 = mapping.Namespace;
}
MessagePartDescription item = new MessagePartDescription(NamingHelper.XmlName(name), str2) {
Index = 0,
Type = type
};
message.Body.Parts.Add(item);
}
if (isResponse)
{
SetReturnValue(message, operation);
}
}
public abstract void Execute(Type objType, Type interfaceType, TypeBuilder builder, List <FieldData> fields, List <MethodData> methods, SerializerOption option);
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.
}
}
}
public static MessageDescription CreateMessageDescription(OperationDescription operation, bool isResponse, MessageDirection direction, string overridingAction, Type type, SerializerOption serializerOption)
{
if ((type != null) && IsMessageContract(type))
{
return CreateFromMessageContract(operation, isResponse, direction, overridingAction, type);
}
MessageDescription message = CreateEmptyMessageDescription(operation, isResponse, direction, overridingAction);
AddMessagePartDescription(operation, isResponse, message, type, serializerOption);
return message;
}
public static void AddInputMessage(OperationDescription operation, string overridingAction, Type type, SerializerOption serializerOption)
{
Fx.Assert(operation.Messages.Count == 0, "Operation already has input message");
bool isResponse = false;
MessageDescription message = MessageBuilder.CreateMessageDescription(
operation, isResponse, MessageDirection.Input, overridingAction, type, serializerOption);
operation.Messages.Add(message);
}
private void EmitIL(ILGenerator il, Type objType, List <FieldData> fields, List <MethodData> methods, SerializerOption option)
{
if (option == SerializerOption.Normal)
{
EmitFieldsDeserializeNormal(il, objType, fields);
}
else
{
EmitFieldsDeserializeCompact(il, objType, fields);
}
for (int i = 0; i < methods.Count; i++)
{
MethodData data = methods[i];
if (data.Type == AccelbufferCallback.OnAfterDeserialization)
{
EmitMessageCallback(il, objType, data.Method);
}
}
}
public static void AddOutputMessage(OperationDescription operation, string overridingAction, Type type, SerializerOption serializerOption)
{
Fx.Assert(operation.Messages.Count > 0, "Operation does not have input message");
Fx.Assert(operation.Messages.Count < 2, "Operation already has output message");
bool isResponse = true;
MessageDescription message = MessageBuilder.CreateMessageDescription(
operation, isResponse, MessageDirection.Output, overridingAction, type, serializerOption);
operation.Messages.Add(message);
}
public static MessageDescription CreateMessageDescription(OperationDescription operation, bool isResponse,
MessageDirection direction, string overridingAction, Type type, SerializerOption serializerOption)
{
MessageDescription result;
if (type != null && IsMessageContract(type))
{
result = CreateFromMessageContract(operation, isResponse, direction, overridingAction, type);
}
else
{
// For Send/Receive, we do not wrap message
result = CreateEmptyMessageDescription(operation, isResponse, direction, overridingAction);
AddMessagePartDescription(operation, isResponse, result, type, serializerOption);
}
return(result);
}
private static void EmitCharDeserialize(ILGenerator il, FieldInfo field, string name, SerializerOption option)
{
MethodInfo method;
if (option == SerializerOption.CompactLayout)
{
EmitEncoding(il, field);
method = s_IteratorType.GetMethod(string.Format(Resources.NextAsWithoutTagName, name));
}
else
{
method = s_IteratorType.GetMethod(Resources.NextAsName + name);
}
il.Emit(OpCodes.Call, method);
}
public static void AddMessagePartDescription(OperationDescription operation, bool isResponse,
MessageDescription message, Type type, SerializerOption serializerOption)
{
if (type != null)
{
string partName;
string partNamespace;
if (serializerOption == SerializerOption.DataContractSerializer)
{
XmlQualifiedName xmlQualifiedName = XsdDataContractExporter.GetRootElementName(type);
if (xmlQualifiedName == null)
{
xmlQualifiedName = XsdDataContractExporter.GetSchemaTypeName(type);
}
if (!xmlQualifiedName.IsEmpty)
{
partName = xmlQualifiedName.Name;
partNamespace = xmlQualifiedName.Namespace;
}
else
{
// For anonymous type, we assign CLR type name and contract namespace to MessagePartDescription
partName = type.Name;
partNamespace = operation.DeclaringContract.Namespace;
}
}
else
{
XmlTypeMapping xmlTypeMapping = XmlReflectionImporter.ImportTypeMapping(type);
partName = xmlTypeMapping.ElementName;
partNamespace = xmlTypeMapping.Namespace;
}
MessagePartDescription messagePart = new MessagePartDescription(NamingHelper.XmlName(partName), partNamespace)
{
Index = 0,
Type = type
// We do not infer MessagePartDescription.ProtectionLevel
};
message.Body.Parts.Add(messagePart);
}
if (isResponse)
{
SetReturnValue(message, operation);
}
}
private static void EmitBooleanSerialize(ILGenerator il, SerializerOption option)
{
MethodInfo method = option == SerializerOption.Normal ? s_WriteValueBoolWithIndexMethod : s_WriteValueBoolMethod;
il.Emit(OpCodes.Call, method);
}
public static void AddInputMessage(OperationDescription operation, string overridingAction, System.Type type, SerializerOption serializerOption)
{
bool isResponse = false;
MessageDescription item = MessageBuilder.CreateMessageDescription(operation, isResponse, MessageDirection.Input, overridingAction, type, serializerOption);
operation.Messages.Add(item);
}
private static void EmitIntSerialize(ILGenerator il, FieldInfo field, Type type, SerializerOption option)
{
EmitNumberFormat(il, field);
MethodInfo method;
if (type.IsEnum)
{
type = Enum.GetUnderlyingType(type);
}
if (option == SerializerOption.Normal)
{
s_WriteValueIntWithIndexTypes[1] = type;
method = s_WriterType.GetMethod(Resources.WriteValueMethodName, s_WriteValueIntWithIndexTypes);
}
else
{
s_WriteValueIntTypes[0] = type;
method = s_WriterType.GetMethod(Resources.WriteValueMethodName, s_WriteValueIntTypes);
}
il.Emit(OpCodes.Call, method);
}
public override void Execute(Type objType, Type interfaceType, TypeBuilder builder, List <FieldData> fields, List <MethodData> methods, SerializerOption option)
{
builder.DefineDefaultConstructor(MethodAttributes.Public);
}
public override void Execute(Type objType, Type interfaceType, TypeBuilder builder, List <FieldData> fields, List <MethodData> methods, SerializerOption option)
{
MethodBuilder method = builder.DefineMethod(Resources.DeserializeMethodName,
s_MethodAttributes,
s_CallingConventions,
objType,
s_DeserializeTypes);
ILGenerator il = method.GetILGenerator();
Predefine(il, objType);
EmitIL(il, objType, fields, methods, option);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ret);
builder.DefineMethodOverride(method, interfaceType.GetMethod(Resources.DeserializeMethodName));
}
private void EmitIL(ILGenerator il, Type objType, List <FieldData> fields, List <MethodData> methods, SerializerOption option)
{
for (int i = 0; i < methods.Count; i++)
{
MethodData data = methods[i];
if (data.Type == AccelbufferCallback.OnBeforeSerialization)
{
EmitMessageCallback(il, objType, data.Method);
}
}
for (int i = 0; i < fields.Count; i++)
{
FieldData data = fields[i];
EmitFieldSerialize(il, data.Field, data.Index, data.CheckRef, option);
}
}
private static void EmitFloatAndBooleanDeserialize(ILGenerator il, string name, SerializerOption option)
{
name = option == SerializerOption.CompactLayout ? string.Format(Resources.NextAsWithoutTagName, name) : Resources.NextAsName + name;
MethodInfo method = s_IteratorType.GetMethod(name);
il.Emit(OpCodes.Call, method);
}
private static void EmitFieldSerialize(ILGenerator il, FieldInfo field, int index, bool checkRef, SerializerOption option)
{
Type fieldType = field.FieldType;
WireType type = GetWireType(field.FieldType, out _);
Label label = default;
if (checkRef && (!fieldType.IsValueType) && (option == SerializerOption.Normal))
{
label = il.DefineLabel();
il.Emit(OpCodes.Ldarg_1); //arg
il.Emit(OpCodes.Ldfld, field); //field
il.Emit(OpCodes.Brfalse, label);
}
il.Emit(OpCodes.Ldarg_2);//writer
if (option == SerializerOption.Normal)
{
il.Emit(OpCodes.Ldc_I4, index);//index
}
il.Emit(OpCodes.Ldarg_1); //arg
il.Emit(OpCodes.Ldfld, field); //field
switch (type)
{
case WireType.Int:
EmitIntSerialize(il, field, fieldType, option);
break;
case WireType.Float:
EmitFloatSerialize(il, fieldType, option);
break;
case WireType.Char:
EmitCharSerialize(il, field, option);
break;
case WireType.String:
EmitStringSerialize(il, field, option);
break;
case WireType.Boolean:
EmitBooleanSerialize(il, option);
break;
default:
EmitComplexSerialize(il, fieldType, option);
break;
}
if (checkRef && (!fieldType.IsValueType) && (option == SerializerOption.Normal))
{
il.MarkLabel(label);
}
}
public static void AddInputMessage(OperationDescription operation, string overridingAction, System.Type type, SerializerOption serializerOption)
{
bool isResponse = false;
MessageDescription item = MessageBuilder.CreateMessageDescription(operation, isResponse, MessageDirection.Input, overridingAction, type, serializerOption);
operation.Messages.Add(item);
}
public static MessageDescription CreateMessageDescription(OperationDescription operation, bool isResponse, MessageDirection direction, string overridingAction, Type type, SerializerOption serializerOption)
{
if ((type != null) && IsMessageContract(type))
{
return(CreateFromMessageContract(operation, isResponse, direction, overridingAction, type));
}
MessageDescription message = CreateEmptyMessageDescription(operation, isResponse, direction, overridingAction);
AddMessagePartDescription(operation, isResponse, message, type, serializerOption);
return(message);
}
public static void AddInputMessage(OperationDescription operation, string overridingAction, Type type, SerializerOption serializerOption)
{
Fx.Assert(operation.Messages.Count == 0, "Operation already has input message");
bool isResponse = false;
MessageDescription message = MessageBuilder.CreateMessageDescription(
operation, isResponse, MessageDirection.Input, overridingAction, type, serializerOption);
operation.Messages.Add(message);
}
public static void AddMessagePartDescription(OperationDescription operation, bool isResponse, MessageDescription message, Type type, SerializerOption serializerOption)
{
if (type != null)
{
string name;
string str2;
if (serializerOption == SerializerOption.DataContractSerializer)
{
XmlQualifiedName rootElementName = XsdDataContractExporter.GetRootElementName(type);
if (rootElementName == null)
{
rootElementName = XsdDataContractExporter.GetSchemaTypeName(type);
}
if (!rootElementName.IsEmpty)
{
name = rootElementName.Name;
str2 = rootElementName.Namespace;
}
else
{
name = type.Name;
str2 = operation.DeclaringContract.Namespace;
}
}
else
{
XmlTypeMapping mapping = XmlReflectionImporter.ImportTypeMapping(type);
name = mapping.ElementName;
str2 = mapping.Namespace;
}
MessagePartDescription item = new MessagePartDescription(NamingHelper.XmlName(name), str2)
{
Index = 0,
Type = type
};
message.Body.Parts.Add(item);
}
if (isResponse)
{
SetReturnValue(message, operation);
}
}
static void AddSerializerProvider(OperationDescription operation, SerializerOption serializerOption)
{
switch (serializerOption)
{
case SerializerOption.DataContractSerializer:
AddDataContractSerializerFormat(operation);
break;
case SerializerOption.XmlSerializer:
AddXmlSerializerFormat(operation);
break;
}
}
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.
}
}
}
public static void AddMessagePartDescription(OperationDescription operation, bool isResponse,
MessageDescription message, Type type, SerializerOption serializerOption)
{
if (type != null)
{
string partName;
string partNamespace;
if (serializerOption == SerializerOption.DataContractSerializer)
{
XmlQualifiedName xmlQualifiedName = XsdDataContractExporter.GetRootElementName(type);
if (xmlQualifiedName == null)
{
xmlQualifiedName = XsdDataContractExporter.GetSchemaTypeName(type);
}
if (!xmlQualifiedName.IsEmpty)
{
partName = xmlQualifiedName.Name;
partNamespace = xmlQualifiedName.Namespace;
}
else
{
// For anonymous type, we assign CLR type name and contract namespace to MessagePartDescription
partName = type.Name;
partNamespace = operation.DeclaringContract.Namespace;
}
}
else
{
XmlTypeMapping xmlTypeMapping = XmlReflectionImporter.ImportTypeMapping(type);
partName = xmlTypeMapping.ElementName;
partNamespace = xmlTypeMapping.Namespace;
}
MessagePartDescription messagePart = new MessagePartDescription(NamingHelper.XmlName(partName), partNamespace)
{
Index = 0,
Type = type
// We do not infer MessagePartDescription.ProtectionLevel
};
message.Body.Parts.Add(messagePart);
}
if (isResponse)
{
SetReturnValue(message, operation);
}
}
public static void AddOutputMessage(OperationDescription operation, string overridingAction, Type type, SerializerOption serializerOption)
{
Fx.Assert(operation.Messages.Count > 0, "Operation does not have input message");
Fx.Assert(operation.Messages.Count < 2, "Operation already has output message");
bool isResponse = true;
MessageDescription message = MessageBuilder.CreateMessageDescription(
operation, isResponse, MessageDirection.Output, overridingAction, type, serializerOption);
operation.Messages.Add(message);
}
