XmlSerializer GetSerializer(MessageBodyDescription desc)
{
if (bodySerializers.ContainsKey(desc))
{
return(bodySerializers [desc]);
}
int count = desc.Parts.Count + (HasReturnValue(desc) ? 1 : 0);
XmlReflectionMember [] members = new XmlReflectionMember [count];
int ind = 0;
if (HasReturnValue(desc))
{
members [ind++] = CreateReflectionMember(desc.ReturnValue, true);
}
foreach (MessagePartDescription partDesc in desc.Parts)
{
members [ind++] = CreateReflectionMember(partDesc, false);
}
XmlReflectionImporter xmlImporter = new XmlReflectionImporter();
// Register known types into xmlImporter.
foreach (var type in OperationKnownTypes)
{
xmlImporter.IncludeType(type);
}
XmlMembersMapping [] partsMapping = new XmlMembersMapping [1];
partsMapping [0] = xmlImporter.ImportMembersMapping(desc.WrapperName, desc.WrapperNamespace, members, true);
bodySerializers [desc] = XmlSerializer.FromMappings(partsMapping) [0];
return(bodySerializers [desc]);
}
public void MessagesNameSpace()
{
ContractDescription cd =
ContractDescription.GetContract(typeof(IFoo2));
OperationDescription od = cd.Operations [0];
Assert.IsNull(od.Messages.Find("Echo"), "#1");
MessageDescription md = od.Messages.Find("http://MonoTests.System.ServiceModel.Description/IFoo2/Echo");
Assert.IsNotNull(md, "#2");
Assert.AreEqual("http://MonoTests.System.ServiceModel.Description/IFoo2/Echo", md.Action, "#3");
Assert.AreEqual(MessageDirection.Input, md.Direction, "#4");
Assert.IsFalse(md.HasProtectionLevel, "#5");
Assert.IsNotNull(md.Headers, "#6");
Assert.AreEqual(0, md.Headers.Count, "#7");
Assert.IsNull(md.MessageType, "#8");
Assert.IsNotNull(md.Properties, "#9");
Assert.AreEqual(0, md.Properties.Count, "#10");
MessageBodyDescription mb = md.Body;
Assert.IsNotNull(mb, "#11");
Assert.AreEqual("Echo", mb.WrapperName, "#12");
Assert.AreEqual("http://MonoTests.System.ServiceModel.Description", mb.WrapperNamespace, "#13");
Assert.IsNotNull(mb.Parts, "#14");
Assert.AreEqual(0, mb.Parts.Count, "#15");
Assert.IsNull(mb.ReturnValue, "#16"); // void Echo()
}
public DataContractBodyWriter(MessageBodyDescription desc, DataContractMessagesFormatter parent, object [] parts)
: base(false)
{
this.desc = desc;
this.parent = parent;
this.parts = parts;
}
protected static object [] CreatePartsArray(MessageBodyDescription desc)
{
if (HasReturnValue(desc))
{
return(new object [desc.Parts.Count + 1]);
}
return(new object [desc.Parts.Count]);
}
public void GetContractIRequestChannel()
{
ContractDescription cd = ContractDescription.GetContract(typeof(IRequestChannel));
Assert.AreEqual(typeof(IRequestChannel), cd.ContractType, "#_1");
Assert.AreEqual("IRequestChannel", cd.Name, "#_2");
Assert.AreEqual("http://schemas.microsoft.com/2005/07/ServiceModel", cd.Namespace, "#_3");
Assert.AreEqual(false, cd.HasProtectionLevel, "#_4");
Assert.AreEqual(SessionMode.NotAllowed, cd.SessionMode, "#_5");
Assert.AreEqual(0, cd.Behaviors.Count, "#_6");
Assert.AreEqual(1, cd.Operations.Count, "#_7");
OperationDescription od = cd.Operations [0];
Assert.IsNull(od.SyncMethod, "#_8");
Assert.IsNull(od.BeginMethod, "#_9");
Assert.IsNull(od.EndMethod, "#_10");
Assert.AreEqual(false, od.IsOneWay, "#_11");
Assert.AreEqual(false, od.HasProtectionLevel, "#_12");
Assert.AreEqual("Request", od.Name, "#_13");
Assert.AreEqual(true, od.IsInitiating, "#_14");
Assert.AreEqual(0, od.Behaviors.Count, "#_15");
Assert.AreEqual(2, od.Messages.Count, "#_16");
foreach (MessageDescription md in od.Messages)
{
if (md.Direction == MessageDirection.Output)
{
Assert.AreEqual("*", md.Action, "#_17");
Assert.AreEqual(false, md.HasProtectionLevel, "#_18");
Assert.AreEqual(0, md.Headers.Count, "#_19");
Assert.AreEqual(0, md.Properties.Count, "#_20");
Assert.IsNull(md.MessageType, "#_21");
MessageBodyDescription mb = md.Body;
Assert.AreEqual(null, mb.WrapperName, "#_22");
Assert.AreEqual(null, mb.WrapperNamespace, "#_23");
Assert.IsNull(mb.ReturnValue, "#_24");
Assert.AreEqual(0, mb.Parts.Count, "#_25");
}
else
{
Assert.AreEqual("*", md.Action, "#_17_");
Assert.AreEqual(false, md.HasProtectionLevel, "#_18_");
Assert.AreEqual(0, md.Headers.Count, "#_19_");
Assert.AreEqual(0, md.Properties.Count, "#_20_");
Assert.IsNull(md.MessageType, "#_21_");
MessageBodyDescription mb = md.Body;
Assert.AreEqual(null, mb.WrapperName, "#_22_");
Assert.AreEqual(null, mb.WrapperNamespace, "#_23_");
Assert.IsNull(mb.ReturnValue, "#_24_");
Assert.AreEqual(0, mb.Parts.Count, "#_25_");
}
}
}
internal MessageBodyDescription(MessageBodyDescription other)
{
this.WrapperName = other.WrapperName;
this.WrapperNamespace = other.WrapperNamespace;
this.parts = new MessagePartDescriptionCollection();
foreach (MessagePartDescription description in other.Parts)
{
this.Parts.Add(description.Clone());
}
if (other.ReturnValue != null)
{
this.ReturnValue = other.ReturnValue.Clone();
}
}
private MessageInfo CreateMessageInfo(DataContractFormatAttribute dataContractFormatAttribute,
MessageDescription messageDescription, DataContractSerializerOperationBehavior serializerFactory)
{
if (messageDescription.IsUntypedMessage)
{
return(null);
}
MessageInfo messageInfo = new MessageInfo();
MessageBodyDescription body = messageDescription.Body;
if (body.WrapperName != null)
{
messageInfo.WrapperName = AddToDictionary(body.WrapperName);
messageInfo.WrapperNamespace = AddToDictionary(body.WrapperNamespace);
}
MessagePartDescriptionCollection parts = body.Parts;
messageInfo.BodyParts = new PartInfo[parts.Count];
for (int i = 0; i < parts.Count; i++)
{
messageInfo.BodyParts[i] = CreatePartInfo(parts[i], dataContractFormatAttribute.Style, serializerFactory);
}
if (IsValidReturnValue(messageDescription.Body.ReturnValue))
{
messageInfo.ReturnPart = CreatePartInfo(messageDescription.Body.ReturnValue, dataContractFormatAttribute.Style, serializerFactory);
}
messageInfo.HeaderDescriptionTable = new MessageHeaderDescriptionTable();
messageInfo.HeaderParts = new PartInfo[messageDescription.Headers.Count];
for (int i = 0; i < messageDescription.Headers.Count; i++)
{
MessageHeaderDescription headerDescription = messageDescription.Headers[i];
if (headerDescription.IsUnknownHeaderCollection)
{
messageInfo.UnknownHeaderDescription = headerDescription;
}
else
{
ValidateDataContractType(headerDescription.Type);
messageInfo.HeaderDescriptionTable.Add(headerDescription.Name, headerDescription.Namespace, headerDescription);
}
messageInfo.HeaderParts[i] = CreatePartInfo(headerDescription, OperationFormatStyle.Document, serializerFactory);
}
messageInfo.AnyHeaders = messageInfo.UnknownHeaderDescription != null || messageInfo.HeaderDescriptionTable.Count > 0;
return(messageInfo);
}
static void ShowMessageBody(MessageDescription message)
{
Console.WriteLine(message.Direction == MessageDirection.Input ?"请求消息：" : "回复消息：");
MessageBodyDescription body = message.Body;
Console.WriteLine("<tns:{0} xmlns:tns=\"{1}\">", body.WrapperName, body.WrapperNamespace);
foreach (var part in body.Parts)
{
Console.WriteLine("\t<tns:{0}>...</tns:{0}>", part.Name);
}
if (null != body.ReturnValue)
{
Console.WriteLine("\t<tns:{0}>...</tns:{0}>",
body.ReturnValue.Name);
}
Console.WriteLine("</tns:{0}>", body.WrapperName);
}
private MessageInfo CreateMessageInfo(DataContractFormatAttribute dataContractFormatAttribute, MessageDescription messageDescription, DataContractSerializerOperationBehavior serializerFactory)
{
if (messageDescription.IsUntypedMessage)
{
return(null);
}
MessageInfo info = new MessageInfo();
MessageBodyDescription body = messageDescription.Body;
if (body.WrapperName != null)
{
info.WrapperName = base.AddToDictionary(body.WrapperName);
info.WrapperNamespace = base.AddToDictionary(body.WrapperNamespace);
}
MessagePartDescriptionCollection parts = body.Parts;
info.BodyParts = new PartInfo[parts.Count];
for (int i = 0; i < parts.Count; i++)
{
info.BodyParts[i] = this.CreatePartInfo(parts[i], dataContractFormatAttribute.Style, serializerFactory);
}
if (OperationFormatter.IsValidReturnValue(messageDescription.Body.ReturnValue))
{
info.ReturnPart = this.CreatePartInfo(messageDescription.Body.ReturnValue, dataContractFormatAttribute.Style, serializerFactory);
}
info.HeaderDescriptionTable = new OperationFormatter.MessageHeaderDescriptionTable();
info.HeaderParts = new PartInfo[messageDescription.Headers.Count];
for (int j = 0; j < messageDescription.Headers.Count; j++)
{
MessageHeaderDescription message = messageDescription.Headers[j];
if (message.IsUnknownHeaderCollection)
{
info.UnknownHeaderDescription = message;
}
else
{
this.ValidateDataContractType(message.Type);
info.HeaderDescriptionTable.Add(message.Name, message.Namespace, message);
}
info.HeaderParts[j] = this.CreatePartInfo(message, OperationFormatStyle.Document, serializerFactory);
}
info.AnyHeaders = (info.UnknownHeaderDescription != null) || (info.HeaderDescriptionTable.Count > 0);
return(info);
}
protected void AddMessageHeader(MessageDescription message, string headerNamespace, string headerName, Type headerType)
{
if (message != null)
{
MessageBodyDescription messageBody = message.Body;
if (messageBody != null)
{
if (headerNamespace.IsEmpty())
{
if (!messageBody.WrapperNamespace.IsEmpty())
{
headerNamespace = messageBody.WrapperNamespace;
if (!messageBody.WrapperName.IsEmpty())
{
headerNamespace += "." + messageBody.Parts[1].Name;
}
}
else if (messageBody.Parts != null && messageBody.Parts.Count > 0)
{
headerNamespace = messageBody.Parts[0].Namespace;
}
}
if (!headerNamespace.IsEmpty())
{
MessageHeaderDescription header = (from h in message.Headers.OfType <MessageHeaderDescription>()
where h.Name.IgnoreCaseCompare(headerName) &&
h.Namespace.IgnoreCaseCompare(headerNamespace)
select h).FirstOrDefault();
if (header == null)
{
header = new MessageHeaderDescription(headerName, headerNamespace);
header.MustUnderstand = true;
header.MemberInfo = headerType;
header.Type = headerType;
header.TypedHeader = true;
message.Headers.Add(header);
}
}
}
}
}
protected static int ParamsOffset(MessageBodyDescription desc)
{
return(HasReturnValue(desc) ? 1 : 0);
}
internal static bool HasReturnValue(MessageBodyDescription desc)
{
return(desc.ReturnValue != null && desc.ReturnValue.Type != typeof(void));
}
/// <summary>
/// Gets the message part description
/// </summary>
/// <param name="messageBodyDescription">A message body description instance</param>
/// <param name="partIndex">The message body description part index.</param>
/// <returns>The message part description</returns>
public static MessagePartDescription GetMessagePartDescription(MessageBodyDescription messageBodyDescription, int partIndex)
{
MessagePartDescription messagePartDescription = messageBodyDescription.Parts[partIndex];
return(messagePartDescription);
}
/// <summary>
/// Gets the message body description
/// </summary>
/// <param name="messageDescription">A message description instance</param>
/// <returns>The message body description</returns>
public static MessageBodyDescription GetMessageBodyDescription(MessageDescription messageDescription)
{
MessageBodyDescription messageBodyDescription = messageDescription.Body;
return(messageBodyDescription);
}
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)));
}
}
}
}
}
void WriteMessagePart(
XmlDictionaryWriter writer, MessageBodyDescription desc, MessagePartDescription partDesc, object obj)
{
parent.GetSerializer(partDesc).WriteObject(writer, obj);
}
