mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
600 lines
28 KiB
C#
600 lines
28 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Runtime;
|
|
using System.Runtime.Serialization;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Description;
|
|
using System.Xml;
|
|
using System.Linq;
|
|
|
|
static class DataContractSerializerDefaults
|
|
{
|
|
internal const bool IgnoreExtensionDataObject = false;
|
|
internal const int MaxItemsInObjectGraph = int.MaxValue;
|
|
|
|
internal static DataContractSerializer CreateSerializer(Type type, int maxItems)
|
|
{
|
|
return CreateSerializer(type, null, maxItems);
|
|
}
|
|
|
|
internal static DataContractSerializer CreateSerializer(Type type, IList<Type> knownTypes, int maxItems)
|
|
{
|
|
return new DataContractSerializer(
|
|
type,
|
|
knownTypes,
|
|
maxItems,
|
|
DataContractSerializerDefaults.IgnoreExtensionDataObject,
|
|
false/*preserveObjectReferences*/,
|
|
null/*dataContractSurrage*/);
|
|
}
|
|
|
|
internal static DataContractSerializer CreateSerializer(Type type, string rootName, string rootNs, int maxItems)
|
|
{
|
|
return CreateSerializer(type, null, rootName, rootNs, maxItems);
|
|
}
|
|
|
|
internal static DataContractSerializer CreateSerializer(Type type, IList<Type> knownTypes, string rootName, string rootNs, int maxItems)
|
|
{
|
|
return new DataContractSerializer(
|
|
type,
|
|
rootName,
|
|
rootNs,
|
|
knownTypes,
|
|
maxItems,
|
|
DataContractSerializerDefaults.IgnoreExtensionDataObject,
|
|
false/*preserveObjectReferences*/,
|
|
null/*dataContractSurrage*/);
|
|
}
|
|
internal static DataContractSerializer CreateSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNs, int maxItems)
|
|
{
|
|
return CreateSerializer(type, null, rootName, rootNs, maxItems);
|
|
}
|
|
|
|
internal static DataContractSerializer CreateSerializer(Type type, IList<Type> knownTypes, XmlDictionaryString rootName, XmlDictionaryString rootNs, int maxItems)
|
|
{
|
|
return new DataContractSerializer(
|
|
type,
|
|
rootName,
|
|
rootNs,
|
|
knownTypes,
|
|
maxItems,
|
|
DataContractSerializerDefaults.IgnoreExtensionDataObject,
|
|
false/*preserveObjectReferences*/,
|
|
null/*dataContractSurrage*/);
|
|
}
|
|
}
|
|
|
|
class DataContractSerializerOperationFormatter : OperationFormatter
|
|
{
|
|
static Type typeOfIQueryable = typeof(IQueryable);
|
|
static Type typeOfIQueryableGeneric = typeof(IQueryable<>);
|
|
static Type typeOfIEnumerable = typeof(IEnumerable);
|
|
static Type typeOfIEnumerableGeneric = typeof(IEnumerable<>);
|
|
|
|
protected MessageInfo requestMessageInfo;
|
|
protected MessageInfo replyMessageInfo;
|
|
IList<Type> knownTypes;
|
|
XsdDataContractExporter dataContractExporter;
|
|
DataContractSerializerOperationBehavior serializerFactory;
|
|
|
|
public DataContractSerializerOperationFormatter(OperationDescription description, DataContractFormatAttribute dataContractFormatAttribute,
|
|
DataContractSerializerOperationBehavior serializerFactory)
|
|
: base(description, dataContractFormatAttribute.Style == OperationFormatStyle.Rpc, false/*isEncoded*/)
|
|
{
|
|
if (description == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
|
|
|
|
this.serializerFactory = serializerFactory ?? new DataContractSerializerOperationBehavior(description);
|
|
foreach (Type type in description.KnownTypes)
|
|
{
|
|
if (knownTypes == null)
|
|
knownTypes = new List<Type>();
|
|
if (type == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxKnownTypeNull, description.Name)));
|
|
ValidateDataContractType(type);
|
|
knownTypes.Add(type);
|
|
}
|
|
requestMessageInfo = CreateMessageInfo(dataContractFormatAttribute, RequestDescription, this.serializerFactory);
|
|
if (ReplyDescription != null)
|
|
replyMessageInfo = CreateMessageInfo(dataContractFormatAttribute, ReplyDescription, this.serializerFactory);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
private void ValidateDataContractType(Type type)
|
|
{
|
|
if (dataContractExporter == null)
|
|
{
|
|
dataContractExporter = new XsdDataContractExporter();
|
|
if (serializerFactory != null && serializerFactory.DataContractSurrogate != null)
|
|
{
|
|
ExportOptions options = new ExportOptions();
|
|
options.DataContractSurrogate = serializerFactory.DataContractSurrogate;
|
|
dataContractExporter.Options = options;
|
|
}
|
|
}
|
|
dataContractExporter.GetSchemaTypeName(type); //Throws if the type is not a valid data contract
|
|
}
|
|
|
|
PartInfo CreatePartInfo(MessagePartDescription part, OperationFormatStyle style, DataContractSerializerOperationBehavior serializerFactory)
|
|
{
|
|
string ns = (style == OperationFormatStyle.Rpc || part.Namespace == null) ? string.Empty : part.Namespace;
|
|
PartInfo partInfo = new PartInfo(part, AddToDictionary(part.Name), AddToDictionary(ns), knownTypes, serializerFactory);
|
|
ValidateDataContractType(partInfo.ContractType);
|
|
return partInfo;
|
|
}
|
|
|
|
protected override void AddHeadersToMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest)
|
|
{
|
|
MessageInfo messageInfo = isRequest ? requestMessageInfo : replyMessageInfo;
|
|
PartInfo[] headerParts = messageInfo.HeaderParts;
|
|
if (headerParts == null || headerParts.Length == 0)
|
|
return;
|
|
MessageHeaders headers = message.Headers;
|
|
for (int i = 0; i < headerParts.Length; i++)
|
|
{
|
|
PartInfo headerPart = headerParts[i];
|
|
MessageHeaderDescription headerDescription = (MessageHeaderDescription)headerPart.Description;
|
|
object headerValue = parameters[headerDescription.Index];
|
|
|
|
if (headerDescription.Multiple)
|
|
{
|
|
if (headerValue != null)
|
|
{
|
|
bool isXmlElement = headerDescription.Type == typeof(XmlElement);
|
|
foreach (object headerItemValue in (IEnumerable)headerValue)
|
|
AddMessageHeaderForParameter(headers, headerPart, message.Version, headerItemValue, isXmlElement);
|
|
}
|
|
}
|
|
else
|
|
AddMessageHeaderForParameter(headers, headerPart, message.Version, headerValue, false/*isXmlElement*/);
|
|
}
|
|
}
|
|
|
|
void AddMessageHeaderForParameter(MessageHeaders headers, PartInfo headerPart, MessageVersion messageVersion, object parameterValue, bool isXmlElement)
|
|
{
|
|
string actor;
|
|
bool mustUnderstand;
|
|
bool relay;
|
|
MessageHeaderDescription headerDescription = (MessageHeaderDescription)headerPart.Description;
|
|
object valueToSerialize = GetContentOfMessageHeaderOfT(headerDescription, parameterValue, out mustUnderstand, out relay, out actor);
|
|
|
|
if (isXmlElement)
|
|
{
|
|
if (valueToSerialize == null)
|
|
return;
|
|
XmlElement xmlElement = (XmlElement)valueToSerialize;
|
|
headers.Add(new XmlElementMessageHeader(this, messageVersion, xmlElement.LocalName, xmlElement.NamespaceURI, mustUnderstand, actor, relay, xmlElement));
|
|
return;
|
|
}
|
|
headers.Add(new DataContractSerializerMessageHeader(headerPart, valueToSerialize, mustUnderstand, actor, relay));
|
|
}
|
|
|
|
protected override void SerializeBody(XmlDictionaryWriter writer, MessageVersion version, string action, MessageDescription messageDescription, object returnValue, object[] parameters, bool isRequest)
|
|
{
|
|
if (writer == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("writer"));
|
|
if (parameters == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parameters"));
|
|
|
|
MessageInfo messageInfo;
|
|
if (isRequest)
|
|
messageInfo = requestMessageInfo;
|
|
else
|
|
messageInfo = replyMessageInfo;
|
|
if (messageInfo.WrapperName != null)
|
|
writer.WriteStartElement(messageInfo.WrapperName, messageInfo.WrapperNamespace);
|
|
if (messageInfo.ReturnPart != null)
|
|
SerializeParameter(writer, messageInfo.ReturnPart, returnValue);
|
|
SerializeParameters(writer, messageInfo.BodyParts, parameters);
|
|
if (messageInfo.WrapperName != null)
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
void SerializeParameters(XmlDictionaryWriter writer, PartInfo[] parts, object[] parameters)
|
|
{
|
|
for (int i = 0; i < parts.Length; i++)
|
|
{
|
|
PartInfo part = parts[i];
|
|
object graph = parameters[part.Description.Index];
|
|
SerializeParameter(writer, part, graph);
|
|
}
|
|
}
|
|
|
|
void SerializeParameter(XmlDictionaryWriter writer, PartInfo part, object graph)
|
|
{
|
|
if (part.Description.Multiple)
|
|
{
|
|
if (graph != null)
|
|
{
|
|
foreach (object item in (IEnumerable)graph)
|
|
SerializeParameterPart(writer, part, item);
|
|
}
|
|
}
|
|
else
|
|
SerializeParameterPart(writer, part, graph);
|
|
}
|
|
|
|
void SerializeParameterPart(XmlDictionaryWriter writer, PartInfo part, object graph)
|
|
{
|
|
try
|
|
{
|
|
part.Serializer.WriteObject(writer, graph);
|
|
}
|
|
catch (SerializationException sx)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
|
|
SR.GetString(SR.SFxInvalidMessageBodyErrorSerializingParameter, part.Description.Namespace, part.Description.Name, sx.Message), sx));
|
|
}
|
|
}
|
|
|
|
protected override void GetHeadersFromMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest)
|
|
{
|
|
MessageInfo messageInfo = isRequest ? requestMessageInfo : replyMessageInfo;
|
|
if (!messageInfo.AnyHeaders)
|
|
return;
|
|
MessageHeaders headers = message.Headers;
|
|
KeyValuePair<Type, ArrayList>[] multipleHeaderValues = null;
|
|
ArrayList elementList = null;
|
|
if (messageInfo.UnknownHeaderDescription != null)
|
|
elementList = new ArrayList();
|
|
|
|
for (int i = 0; i < headers.Count; i++)
|
|
{
|
|
MessageHeaderInfo header = headers[i];
|
|
MessageHeaderDescription headerDescription = messageInfo.HeaderDescriptionTable.Get(header.Name, header.Namespace);
|
|
if (headerDescription != null)
|
|
{
|
|
if (header.MustUnderstand)
|
|
headers.UnderstoodHeaders.Add(header);
|
|
|
|
object item = null;
|
|
XmlDictionaryReader headerReader = headers.GetReaderAtHeader(i);
|
|
try
|
|
{
|
|
object dataValue = DeserializeHeaderContents(headerReader, messageDescription, headerDescription);
|
|
if (headerDescription.TypedHeader)
|
|
item = TypedHeaderManager.Create(headerDescription.Type, dataValue, headers[i].MustUnderstand, headers[i].Relay, headers[i].Actor);
|
|
else
|
|
item = dataValue;
|
|
}
|
|
finally
|
|
{
|
|
headerReader.Close();
|
|
}
|
|
|
|
if (headerDescription.Multiple)
|
|
{
|
|
if (multipleHeaderValues == null)
|
|
multipleHeaderValues = new KeyValuePair<Type, ArrayList>[parameters.Length];
|
|
if (multipleHeaderValues[headerDescription.Index].Key == null)
|
|
{
|
|
multipleHeaderValues[headerDescription.Index] = new KeyValuePair<System.Type, System.Collections.ArrayList>(headerDescription.TypedHeader ? TypedHeaderManager.GetMessageHeaderType(headerDescription.Type) : headerDescription.Type, new ArrayList());
|
|
}
|
|
multipleHeaderValues[headerDescription.Index].Value.Add(item);
|
|
}
|
|
else
|
|
parameters[headerDescription.Index] = item;
|
|
}
|
|
else if (messageInfo.UnknownHeaderDescription != null)
|
|
{
|
|
MessageHeaderDescription unknownHeaderDescription = messageInfo.UnknownHeaderDescription;
|
|
XmlDictionaryReader headerReader = headers.GetReaderAtHeader(i);
|
|
try
|
|
{
|
|
XmlDocument doc = new XmlDocument();
|
|
object dataValue = doc.ReadNode(headerReader);
|
|
if (dataValue != null && unknownHeaderDescription.TypedHeader)
|
|
dataValue = TypedHeaderManager.Create(unknownHeaderDescription.Type, dataValue, headers[i].MustUnderstand, headers[i].Relay, headers[i].Actor);
|
|
elementList.Add(dataValue);
|
|
}
|
|
finally
|
|
{
|
|
headerReader.Close();
|
|
}
|
|
}
|
|
}
|
|
if (multipleHeaderValues != null)
|
|
{
|
|
for (int i = 0; i < parameters.Length; i++)
|
|
{
|
|
if (multipleHeaderValues[i].Key != null)
|
|
parameters[i] = multipleHeaderValues[i].Value.ToArray(multipleHeaderValues[i].Key);
|
|
}
|
|
}
|
|
if (messageInfo.UnknownHeaderDescription != null)
|
|
parameters[messageInfo.UnknownHeaderDescription.Index] = elementList.ToArray(messageInfo.UnknownHeaderDescription.TypedHeader ? typeof(MessageHeader<XmlElement>) : typeof(XmlElement));
|
|
}
|
|
|
|
object DeserializeHeaderContents(XmlDictionaryReader reader, MessageDescription messageDescription, MessageHeaderDescription headerDescription)
|
|
{
|
|
bool isQueryable;
|
|
Type dataContractType = DataContractSerializerOperationFormatter.GetSubstituteDataContractType(headerDescription.Type, out isQueryable);
|
|
XmlObjectSerializer serializerLocal = serializerFactory.CreateSerializer(dataContractType, headerDescription.Name, headerDescription.Namespace, this.knownTypes);
|
|
object val = serializerLocal.ReadObject(reader);
|
|
if (isQueryable && val != null)
|
|
{
|
|
return Queryable.AsQueryable((IEnumerable)val);
|
|
}
|
|
return val;
|
|
}
|
|
|
|
protected override object DeserializeBody(XmlDictionaryReader reader, MessageVersion version, string action, MessageDescription messageDescription, object[] parameters, bool isRequest)
|
|
{
|
|
if (reader == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("reader"));
|
|
if (parameters == null) throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parameters"));
|
|
|
|
MessageInfo messageInfo;
|
|
if (isRequest)
|
|
messageInfo = requestMessageInfo;
|
|
else
|
|
messageInfo = replyMessageInfo;
|
|
|
|
if (messageInfo.WrapperName != null)
|
|
{
|
|
if (!reader.IsStartElement(messageInfo.WrapperName, messageInfo.WrapperNamespace))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.GetString(SR.SFxInvalidMessageBody, messageInfo.WrapperName, messageInfo.WrapperNamespace, reader.NodeType, reader.Name, reader.NamespaceURI)));
|
|
bool isEmptyElement = reader.IsEmptyElement;
|
|
reader.Read();
|
|
if (isEmptyElement)
|
|
return null;
|
|
}
|
|
object returnValue = null;
|
|
if (messageInfo.ReturnPart != null)
|
|
{
|
|
while (true)
|
|
{
|
|
PartInfo part = messageInfo.ReturnPart;
|
|
if (part.Serializer.IsStartObject(reader))
|
|
{
|
|
returnValue = DeserializeParameter(reader, part, isRequest);
|
|
break;
|
|
}
|
|
if (!reader.IsStartElement())
|
|
break;
|
|
OperationFormatter.TraceAndSkipElement(reader);
|
|
}
|
|
}
|
|
DeserializeParameters(reader, messageInfo.BodyParts, parameters, isRequest);
|
|
if (messageInfo.WrapperName != null)
|
|
reader.ReadEndElement();
|
|
return returnValue;
|
|
}
|
|
|
|
void DeserializeParameters(XmlDictionaryReader reader, PartInfo[] parts, object[] parameters, bool isRequest)
|
|
{
|
|
int nextPartIndex = 0;
|
|
while (reader.IsStartElement())
|
|
{
|
|
for (int i = nextPartIndex; i < parts.Length; i++)
|
|
{
|
|
PartInfo part = parts[i];
|
|
if (part.Serializer.IsStartObject(reader))
|
|
{
|
|
object parameterValue = DeserializeParameter(reader, part, isRequest);
|
|
parameters[part.Description.Index] = parameterValue;
|
|
nextPartIndex = i + 1;
|
|
}
|
|
else
|
|
parameters[part.Description.Index] = null;
|
|
}
|
|
|
|
if (reader.IsStartElement())
|
|
OperationFormatter.TraceAndSkipElement(reader);
|
|
}
|
|
}
|
|
|
|
object DeserializeParameter(XmlDictionaryReader reader, PartInfo part, bool isRequest)
|
|
{
|
|
if (part.Description.Multiple)
|
|
{
|
|
ArrayList items = new ArrayList();
|
|
while (part.Serializer.IsStartObject(reader))
|
|
items.Add(DeserializeParameterPart(reader, part, isRequest));
|
|
return items.ToArray(part.Description.Type);
|
|
}
|
|
return DeserializeParameterPart(reader, part, isRequest);
|
|
}
|
|
|
|
object DeserializeParameterPart(XmlDictionaryReader reader, PartInfo part, bool isRequest)
|
|
{
|
|
object val;
|
|
try
|
|
{
|
|
val = part.ReadObject(reader);
|
|
}
|
|
catch (System.InvalidOperationException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
SR.GetString(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e));
|
|
}
|
|
catch (System.Runtime.Serialization.InvalidDataContractException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(
|
|
SR.GetString(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e));
|
|
}
|
|
catch (System.FormatException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
OperationFormatter.CreateDeserializationFailedFault(
|
|
SR.GetString(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
|
|
part.Description.Namespace, part.Description.Name, e.Message),
|
|
e));
|
|
}
|
|
catch (System.Runtime.Serialization.SerializationException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
OperationFormatter.CreateDeserializationFailedFault(
|
|
SR.GetString(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
|
|
part.Description.Namespace, part.Description.Name, e.Message),
|
|
e));
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
internal static Type GetSubstituteDataContractType(Type type, out bool isQueryable)
|
|
{
|
|
if (type == typeOfIQueryable)
|
|
{
|
|
isQueryable = true;
|
|
return typeOfIEnumerable;
|
|
}
|
|
|
|
if (type.IsGenericType &&
|
|
type.GetGenericTypeDefinition() == typeOfIQueryableGeneric)
|
|
{
|
|
isQueryable = true;
|
|
return typeOfIEnumerableGeneric.MakeGenericType(type.GetGenericArguments());
|
|
}
|
|
|
|
isQueryable = false;
|
|
return type;
|
|
}
|
|
|
|
|
|
class DataContractSerializerMessageHeader : XmlObjectSerializerHeader
|
|
{
|
|
PartInfo headerPart;
|
|
|
|
public DataContractSerializerMessageHeader(PartInfo headerPart, object headerValue, bool mustUnderstand, string actor, bool relay)
|
|
: base(headerPart.DictionaryName.Value, headerPart.DictionaryNamespace.Value, headerValue, headerPart.Serializer, mustUnderstand, actor ?? string.Empty, relay)
|
|
{
|
|
this.headerPart = headerPart;
|
|
}
|
|
|
|
protected override void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
|
|
{
|
|
//Prefix needed since there may be xsi:type attribute at toplevel with qname value where ns = ""
|
|
string prefix = (this.Namespace == null || this.Namespace.Length == 0) ? string.Empty : "h";
|
|
writer.WriteStartElement(prefix, headerPart.DictionaryName, headerPart.DictionaryNamespace);
|
|
WriteHeaderAttributes(writer, messageVersion);
|
|
}
|
|
}
|
|
|
|
|
|
protected class MessageInfo
|
|
{
|
|
internal PartInfo[] HeaderParts;
|
|
internal XmlDictionaryString WrapperName;
|
|
internal XmlDictionaryString WrapperNamespace;
|
|
internal PartInfo[] BodyParts;
|
|
internal PartInfo ReturnPart;
|
|
internal MessageHeaderDescriptionTable HeaderDescriptionTable;
|
|
internal MessageHeaderDescription UnknownHeaderDescription;
|
|
internal bool AnyHeaders;
|
|
}
|
|
|
|
protected class PartInfo
|
|
{
|
|
XmlDictionaryString dictionaryName;
|
|
XmlDictionaryString dictionaryNamespace;
|
|
MessagePartDescription description;
|
|
XmlObjectSerializer serializer;
|
|
IList<Type> knownTypes;
|
|
DataContractSerializerOperationBehavior serializerFactory;
|
|
Type contractType;
|
|
bool isQueryable;
|
|
|
|
public PartInfo(MessagePartDescription description, XmlDictionaryString dictionaryName, XmlDictionaryString dictionaryNamespace,
|
|
IList<Type> knownTypes, DataContractSerializerOperationBehavior behavior)
|
|
{
|
|
this.dictionaryName = dictionaryName;
|
|
this.dictionaryNamespace = dictionaryNamespace;
|
|
this.description = description;
|
|
this.knownTypes = knownTypes;
|
|
this.serializerFactory = behavior;
|
|
|
|
this.contractType = DataContractSerializerOperationFormatter.GetSubstituteDataContractType(description.Type, out this.isQueryable);
|
|
}
|
|
|
|
public Type ContractType
|
|
{
|
|
get { return this.contractType; }
|
|
}
|
|
|
|
public MessagePartDescription Description
|
|
{
|
|
get { return description; }
|
|
}
|
|
|
|
public XmlDictionaryString DictionaryName
|
|
{
|
|
get { return dictionaryName; }
|
|
}
|
|
|
|
public XmlDictionaryString DictionaryNamespace
|
|
{
|
|
get { return dictionaryNamespace; }
|
|
}
|
|
|
|
public XmlObjectSerializer Serializer
|
|
{
|
|
get
|
|
{
|
|
if (serializer == null)
|
|
{
|
|
serializer = serializerFactory.CreateSerializer(contractType, DictionaryName, DictionaryNamespace, knownTypes);
|
|
}
|
|
return serializer;
|
|
}
|
|
}
|
|
|
|
public object ReadObject(XmlDictionaryReader reader)
|
|
{
|
|
return this.ReadObject(reader, this.Serializer);
|
|
}
|
|
|
|
public object ReadObject(XmlDictionaryReader reader, XmlObjectSerializer serializer)
|
|
{
|
|
object val = this.serializer.ReadObject(reader, false /* verifyObjectName */);
|
|
if (this.isQueryable && val != null)
|
|
{
|
|
return Queryable.AsQueryable((IEnumerable)val);
|
|
}
|
|
return val;
|
|
}
|
|
}
|
|
}
|
|
}
|