Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

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