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
795 lines
35 KiB
C#
795 lines
35 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System.Collections;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Description;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Reflection;
|
|
using System.Xml;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.Runtime.Serialization;
|
|
using System.Net;
|
|
using System.Runtime.Serialization.Json;
|
|
|
|
class DataContractJsonSerializerOperationFormatter : DataContractSerializerOperationFormatter
|
|
{
|
|
bool isBareMessageContractReply;
|
|
bool isBareMessageContractRequest;
|
|
// isWrapped is true when the user has explicitly chosen the response or request format to be Wrapped (allowed only in WebHttpBehavior)
|
|
bool isWrapped;
|
|
bool useAspNetAjaxJson;
|
|
string callbackParameterName;
|
|
|
|
public DataContractJsonSerializerOperationFormatter(OperationDescription description, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, System.Runtime.Serialization.IDataContractSurrogate dataContractSurrogate, bool isWrapped, bool useAspNetAjaxJson, string callbackParameterName)
|
|
: base(description, TypeLoader.DefaultDataContractFormatAttribute, new DataContractJsonSerializerOperationBehavior(description, maxItemsInObjectGraph, ignoreExtensionDataObject, dataContractSurrogate, useAspNetAjaxJson))
|
|
{
|
|
if (this.requestMessageInfo != null)
|
|
{
|
|
if (this.requestMessageInfo.WrapperName == null)
|
|
{
|
|
isBareMessageContractRequest = true;
|
|
}
|
|
else
|
|
{
|
|
this.requestMessageInfo.WrapperName = JsonGlobals.rootDictionaryString;
|
|
this.requestMessageInfo.WrapperNamespace = XmlDictionaryString.Empty;
|
|
}
|
|
}
|
|
|
|
if (this.replyMessageInfo != null)
|
|
{
|
|
if (this.replyMessageInfo.WrapperName == null)
|
|
{
|
|
isBareMessageContractReply = true;
|
|
}
|
|
else
|
|
{
|
|
if (useAspNetAjaxJson)
|
|
{
|
|
this.replyMessageInfo.WrapperName = JsonGlobals.dDictionaryString;
|
|
}
|
|
else
|
|
{
|
|
this.replyMessageInfo.WrapperName = JsonGlobals.rootDictionaryString;
|
|
}
|
|
this.replyMessageInfo.WrapperNamespace = XmlDictionaryString.Empty;
|
|
}
|
|
}
|
|
|
|
if ((this.requestStreamFormatter != null) && (this.requestStreamFormatter.WrapperName != null))
|
|
{
|
|
this.requestStreamFormatter.WrapperName = JsonGlobals.rootString;
|
|
this.requestStreamFormatter.WrapperNamespace = string.Empty;
|
|
}
|
|
|
|
if ((this.replyStreamFormatter != null) && (this.replyStreamFormatter.WrapperName != null))
|
|
{
|
|
this.replyStreamFormatter.WrapperName = JsonGlobals.rootString;
|
|
this.replyStreamFormatter.WrapperNamespace = string.Empty;
|
|
}
|
|
this.isWrapped = isWrapped;
|
|
this.useAspNetAjaxJson = useAspNetAjaxJson;
|
|
this.callbackParameterName = callbackParameterName;
|
|
}
|
|
|
|
internal static bool IsJsonLocalName(XmlDictionaryReader reader, string elementName)
|
|
{
|
|
if (reader.IsStartElement(JsonGlobals.itemDictionaryString, JsonGlobals.itemDictionaryString))
|
|
{
|
|
if (reader.MoveToAttribute(JsonGlobals.itemString))
|
|
{
|
|
return (reader.Value == elementName);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
internal static bool IsStartElement(XmlDictionaryReader reader, string elementName)
|
|
{
|
|
if (reader.IsStartElement(elementName))
|
|
{
|
|
return true;
|
|
}
|
|
return IsJsonLocalName(reader, elementName);
|
|
}
|
|
|
|
internal static bool IsStartElement(XmlDictionaryReader reader, XmlDictionaryString elementName, XmlDictionaryString elementNamespace)
|
|
{
|
|
if (reader.IsStartElement(elementName, elementNamespace))
|
|
{
|
|
return true;
|
|
}
|
|
return IsJsonLocalName(reader, (elementName == null) ? null : elementName.Value);
|
|
}
|
|
|
|
protected override void AddHeadersToMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest)
|
|
{
|
|
if (message != null)
|
|
{
|
|
message.Properties.Add(WebBodyFormatMessageProperty.Name, WebBodyFormatMessageProperty.JsonProperty);
|
|
}
|
|
base.AddHeadersToMessage(message, messageDescription, parameters, isRequest);
|
|
}
|
|
|
|
protected override object DeserializeBody(XmlDictionaryReader reader, MessageVersion version, string action, MessageDescription messageDescription, object[] parameters, bool isRequest)
|
|
{
|
|
if (reader == null)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("reader"));
|
|
}
|
|
if (parameters == null)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parameters"));
|
|
}
|
|
|
|
if (reader.EOF)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
if ((isRequest && this.isBareMessageContractRequest) || (!isRequest && isBareMessageContractReply))
|
|
{
|
|
return DeserializeBareMessageContract(reader, parameters, isRequest);
|
|
}
|
|
|
|
object returnValue = null;
|
|
|
|
if (isRequest || (isWrapped && !useAspNetAjaxJson))
|
|
{
|
|
ValidateTypeObjectAttribute(reader, isRequest);
|
|
returnValue = DeserializeBodyCore(reader, parameters, isRequest);
|
|
}
|
|
else
|
|
{
|
|
if (useAspNetAjaxJson)
|
|
{
|
|
ReadRootElement(reader);
|
|
}
|
|
if (useAspNetAjaxJson && messageDescription.IsVoid)
|
|
{
|
|
ReadVoidReturn(reader);
|
|
}
|
|
else if (replyMessageInfo.ReturnPart != null)
|
|
{
|
|
PartInfo part = replyMessageInfo.ReturnPart;
|
|
DataContractJsonSerializer serializer = part.Serializer as DataContractJsonSerializer;
|
|
|
|
if (useAspNetAjaxJson)
|
|
{
|
|
serializer = RecreateDataContractJsonSerializer(serializer, JsonGlobals.dString);
|
|
VerifyIsStartElement(reader, JsonGlobals.dString);
|
|
}
|
|
else
|
|
{
|
|
serializer = RecreateDataContractJsonSerializer(serializer, JsonGlobals.rootString);
|
|
VerifyIsStartElement(reader, JsonGlobals.rootString);
|
|
}
|
|
|
|
if (serializer.IsStartObject(reader))
|
|
{
|
|
try
|
|
{
|
|
returnValue = part.ReadObject(reader, serializer);
|
|
}
|
|
catch (System.InvalidOperationException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e));
|
|
}
|
|
catch (System.Runtime.Serialization.InvalidDataContractException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new System.Runtime.Serialization.InvalidDataContractException(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e));
|
|
}
|
|
catch (System.FormatException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
OperationFormatter.CreateDeserializationFailedFault(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
|
|
part.Description.Namespace, part.Description.Name, e.Message),
|
|
e));
|
|
}
|
|
catch (System.Runtime.Serialization.SerializationException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
OperationFormatter.CreateDeserializationFailedFault(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
|
|
part.Description.Namespace, part.Description.Name, e.Message),
|
|
e));
|
|
}
|
|
}
|
|
}
|
|
else if (replyMessageInfo.BodyParts != null)
|
|
{
|
|
ValidateTypeObjectAttribute(reader, isRequest);
|
|
returnValue = DeserializeBodyCore(reader, parameters, isRequest);
|
|
}
|
|
|
|
while (reader.IsStartElement())
|
|
{
|
|
OperationFormatter.TraceAndSkipElement(reader);
|
|
}
|
|
|
|
if (useAspNetAjaxJson)
|
|
{
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
|
|
return returnValue;
|
|
}
|
|
|
|
protected override void GetHeadersFromMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest)
|
|
{
|
|
if (message != null)
|
|
{
|
|
object prop;
|
|
message.Properties.TryGetValue(WebBodyFormatMessageProperty.Name, out prop);
|
|
WebBodyFormatMessageProperty formatProperty = (prop as WebBodyFormatMessageProperty);
|
|
if (formatProperty == null)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR2.GetString(SR2.MessageFormatPropertyNotFound2, this.OperationName)));
|
|
}
|
|
if (formatProperty.Format != WebContentFormat.Json)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR2.GetString(SR2.InvalidHttpMessageFormat3, this.OperationName, formatProperty.Format, WebContentFormat.Json)));
|
|
}
|
|
}
|
|
base.GetHeadersFromMessage(message, messageDescription, parameters, isRequest);
|
|
}
|
|
|
|
protected override void SerializeBody(XmlDictionaryWriter writer, MessageVersion version, string action, MessageDescription messageDescription, object returnValue, object[] parameters, bool isRequest)
|
|
{
|
|
if ((isRequest && this.isBareMessageContractRequest) || (!isRequest && isBareMessageContractReply))
|
|
{
|
|
SerializeBareMessageContract(writer, parameters, isRequest);
|
|
}
|
|
else
|
|
{
|
|
bool isJsonp = WebHttpBehavior.TrySetupJavascriptCallback(callbackParameterName) != null;
|
|
bool useAspNetJsonWrapper = !isJsonp && useAspNetAjaxJson;
|
|
|
|
if (isRequest || (isWrapped && !useAspNetJsonWrapper))
|
|
{
|
|
SerializeBody(writer, returnValue, parameters, isRequest);
|
|
}
|
|
else
|
|
{
|
|
if (useAspNetJsonWrapper)
|
|
{
|
|
writer.WriteStartElement(JsonGlobals.rootString);
|
|
writer.WriteAttributeString(JsonGlobals.typeString, JsonGlobals.objectString);
|
|
}
|
|
|
|
if (useAspNetJsonWrapper && messageDescription.IsVoid)
|
|
{
|
|
WriteVoidReturn(writer);
|
|
}
|
|
else if (isJsonp && messageDescription.IsVoid)
|
|
{
|
|
writer.WriteStartElement(JsonGlobals.rootString);
|
|
writer.WriteAttributeString(JsonGlobals.typeString, JsonGlobals.nullString);
|
|
writer.WriteEndElement();
|
|
}
|
|
else if (replyMessageInfo.ReturnPart != null)
|
|
{
|
|
DataContractJsonSerializer serializer = replyMessageInfo.ReturnPart.Serializer as DataContractJsonSerializer;
|
|
if (useAspNetJsonWrapper)
|
|
{
|
|
serializer = RecreateDataContractJsonSerializer(serializer, JsonGlobals.dString);
|
|
}
|
|
else
|
|
{
|
|
serializer = RecreateDataContractJsonSerializer(serializer, JsonGlobals.rootString);
|
|
}
|
|
|
|
try
|
|
{
|
|
serializer.WriteObject(writer, returnValue);
|
|
}
|
|
catch (SerializationException sx)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorSerializingParameter, replyMessageInfo.ReturnPart.Description.Namespace, replyMessageInfo.ReturnPart.Description.Name, sx.Message), sx));
|
|
}
|
|
}
|
|
else if (replyMessageInfo.BodyParts != null)
|
|
{
|
|
SerializeBody(writer, returnValue, parameters, isRequest);
|
|
}
|
|
|
|
if (useAspNetJsonWrapper)
|
|
{
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static DataContractJsonSerializer RecreateDataContractJsonSerializer(DataContractJsonSerializer serializer, string newRootName)
|
|
{
|
|
DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings
|
|
{
|
|
RootName = newRootName,
|
|
KnownTypes = serializer.KnownTypes,
|
|
MaxItemsInObjectGraph = serializer.MaxItemsInObjectGraph,
|
|
IgnoreExtensionDataObject = serializer.IgnoreExtensionDataObject,
|
|
DataContractSurrogate = serializer.DataContractSurrogate,
|
|
EmitTypeInformation = serializer.EmitTypeInformation,
|
|
DateTimeFormat = serializer.DateTimeFormat,
|
|
UseSimpleDictionaryFormat = serializer.UseSimpleDictionaryFormat
|
|
};
|
|
return new DataContractJsonSerializer(serializer.GetDeserializeType(), settings);
|
|
}
|
|
|
|
object DeserializeBareMessageContract(XmlDictionaryReader reader, object[] parameters, bool isRequest)
|
|
{
|
|
MessageInfo messageInfo;
|
|
if (isRequest)
|
|
{
|
|
messageInfo = this.requestMessageInfo;
|
|
}
|
|
else
|
|
{
|
|
messageInfo = this.replyMessageInfo;
|
|
}
|
|
|
|
if (useAspNetAjaxJson && !isRequest)
|
|
{
|
|
ReadRootElement(reader);
|
|
if (messageInfo.BodyParts.Length == 0)
|
|
{
|
|
ReadVoidReturn(reader);
|
|
}
|
|
}
|
|
if (messageInfo.BodyParts.Length > 0)
|
|
{
|
|
PartInfo part = messageInfo.BodyParts[0];
|
|
DataContractJsonSerializer serializer = part.Serializer as DataContractJsonSerializer;
|
|
if (useAspNetAjaxJson && !isRequest)
|
|
{
|
|
serializer = RecreateDataContractJsonSerializer(serializer, JsonGlobals.dString);
|
|
}
|
|
else
|
|
{
|
|
serializer = RecreateDataContractJsonSerializer(serializer, JsonGlobals.rootString);
|
|
}
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (serializer.IsStartObject(reader))
|
|
{
|
|
try
|
|
{
|
|
parameters[part.Description.Index] = part.ReadObject(reader, serializer);
|
|
break;
|
|
}
|
|
catch (System.InvalidOperationException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e));
|
|
}
|
|
catch (System.Runtime.Serialization.InvalidDataContractException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e));
|
|
}
|
|
catch (System.FormatException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
OperationFormatter.CreateDeserializationFailedFault(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
|
|
part.Description.Namespace, part.Description.Name, e.Message),
|
|
e));
|
|
}
|
|
catch (System.Runtime.Serialization.SerializationException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
OperationFormatter.CreateDeserializationFailedFault(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
|
|
part.Description.Namespace, part.Description.Name, e.Message),
|
|
e));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
OperationFormatter.TraceAndSkipElement(reader);
|
|
}
|
|
}
|
|
while (reader.IsStartElement())
|
|
{
|
|
OperationFormatter.TraceAndSkipElement(reader);
|
|
}
|
|
}
|
|
if (this.useAspNetAjaxJson && !isRequest)
|
|
{
|
|
reader.ReadEndElement();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
object DeserializeBodyCore(XmlDictionaryReader reader, object[] parameters, bool isRequest)
|
|
{
|
|
MessageInfo messageInfo;
|
|
if (isRequest)
|
|
{
|
|
messageInfo = requestMessageInfo;
|
|
}
|
|
else
|
|
{
|
|
messageInfo = replyMessageInfo;
|
|
}
|
|
|
|
if (messageInfo.WrapperName != null)
|
|
{
|
|
VerifyIsStartElement(reader, messageInfo.WrapperName, messageInfo.WrapperNamespace);
|
|
bool isEmptyElement = reader.IsEmptyElement;
|
|
reader.Read();
|
|
if (isEmptyElement)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
object returnValue = null;
|
|
DeserializeParameters(reader, messageInfo.BodyParts, parameters, messageInfo.ReturnPart, ref returnValue);
|
|
if (messageInfo.WrapperName != null)
|
|
{
|
|
reader.ReadEndElement();
|
|
}
|
|
return returnValue;
|
|
}
|
|
|
|
object DeserializeParameter(XmlDictionaryReader reader, PartInfo part)
|
|
{
|
|
if (part.Description.Multiple)
|
|
{
|
|
ArrayList items = new ArrayList();
|
|
while (part.Serializer.IsStartObject(reader))
|
|
{
|
|
items.Add(DeserializeParameterPart(reader, part));
|
|
}
|
|
return items.ToArray(part.Description.Type);
|
|
}
|
|
return DeserializeParameterPart(reader, part);
|
|
}
|
|
|
|
object DeserializeParameterPart(XmlDictionaryReader reader, PartInfo part)
|
|
{
|
|
object val;
|
|
try
|
|
{
|
|
val = part.ReadObject(reader);
|
|
}
|
|
catch (System.InvalidOperationException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e));
|
|
}
|
|
catch (System.Runtime.Serialization.InvalidDataContractException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e));
|
|
}
|
|
catch (System.FormatException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
OperationFormatter.CreateDeserializationFailedFault(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
|
|
part.Description.Namespace, part.Description.Name, e.Message),
|
|
e));
|
|
}
|
|
catch (System.Runtime.Serialization.SerializationException e)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
OperationFormatter.CreateDeserializationFailedFault(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
|
|
part.Description.Namespace, part.Description.Name, e.Message),
|
|
e));
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
void DeserializeParameters(XmlDictionaryReader reader, PartInfo[] parts, object[] parameters, PartInfo returnInfo, ref object returnValue)
|
|
{
|
|
bool[] setParameters = new bool[parameters.Length];
|
|
bool hasReadReturnValue = false;
|
|
int currentIndex = 0;
|
|
|
|
while (reader.IsStartElement())
|
|
{
|
|
bool hasReadParameter = false;
|
|
|
|
for (int i = 0, index = currentIndex; i < parts.Length; i++, index = (index + 1) % parts.Length)
|
|
{
|
|
PartInfo part = parts[index];
|
|
if (part.Serializer.IsStartObject(reader))
|
|
{
|
|
currentIndex = i;
|
|
parameters[part.Description.Index] = DeserializeParameter(reader, part);
|
|
setParameters[part.Description.Index] = true;
|
|
hasReadParameter = true;
|
|
}
|
|
}
|
|
|
|
if (!hasReadParameter)
|
|
{
|
|
if ((returnInfo != null) && !hasReadReturnValue && returnInfo.Serializer.IsStartObject(reader))
|
|
{
|
|
returnValue = DeserializeParameter(reader, returnInfo);
|
|
hasReadReturnValue = true;
|
|
}
|
|
else
|
|
{
|
|
OperationFormatter.TraceAndSkipElement(reader);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < parameters.Length; i++)
|
|
{
|
|
if (!setParameters[i])
|
|
{
|
|
parameters[i] = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ReadRootElement(XmlDictionaryReader reader)
|
|
{
|
|
if (!IsStartElement(reader, JsonGlobals.rootString))
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBody, JsonGlobals.rootString, string.Empty, reader.NodeType, reader.Name, reader.NamespaceURI)));
|
|
}
|
|
string typeAttribute = reader.GetAttribute(JsonGlobals.typeString);
|
|
if (!typeAttribute.Equals(JsonGlobals.objectString, StringComparison.Ordinal))
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
XmlObjectSerializer.CreateSerializationException(SR2.GetString(SR2.JsonFormatterExpectedAttributeObject, typeAttribute)));
|
|
}
|
|
|
|
bool isEmptyElement = reader.IsEmptyElement;
|
|
reader.Read();
|
|
if (isEmptyElement)
|
|
{
|
|
//throw in aspnet case
|
|
}
|
|
}
|
|
|
|
void ReadVoidReturn(XmlDictionaryReader reader)
|
|
{
|
|
VerifyIsStartElement(reader, JsonGlobals.dString);
|
|
string typeAttribute = reader.GetAttribute(JsonGlobals.typeString);
|
|
if (!typeAttribute.Equals(JsonGlobals.nullString, StringComparison.Ordinal))
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
XmlObjectSerializer.CreateSerializationException(SR2.GetString(SR2.JsonFormatterExpectedAttributeNull, typeAttribute)));
|
|
}
|
|
OperationFormatter.TraceAndSkipElement(reader);
|
|
}
|
|
|
|
void SerializeBareMessageContract(XmlDictionaryWriter writer, object[] parameters, bool isRequest)
|
|
{
|
|
bool useAspNetJsonWrapper = WebHttpBehavior.TrySetupJavascriptCallback(callbackParameterName) == null && useAspNetAjaxJson;
|
|
|
|
if (writer == null)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("writer"));
|
|
}
|
|
|
|
if (parameters == null)
|
|
{
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parameters"));
|
|
}
|
|
|
|
MessageInfo messageInfo;
|
|
if (isRequest)
|
|
{
|
|
messageInfo = this.requestMessageInfo;
|
|
}
|
|
else
|
|
{
|
|
messageInfo = this.replyMessageInfo;
|
|
}
|
|
if (useAspNetJsonWrapper && !isRequest)
|
|
{
|
|
writer.WriteStartElement(JsonGlobals.rootString);
|
|
writer.WriteAttributeString(JsonGlobals.typeString, JsonGlobals.objectString);
|
|
if (messageInfo.BodyParts.Length == 0)
|
|
{
|
|
WriteVoidReturn(writer);
|
|
}
|
|
}
|
|
if (messageInfo.BodyParts.Length > 0)
|
|
{
|
|
PartInfo part = messageInfo.BodyParts[0];
|
|
DataContractJsonSerializer serializer = part.Serializer as DataContractJsonSerializer;
|
|
if (useAspNetJsonWrapper && !isRequest)
|
|
{
|
|
serializer = RecreateDataContractJsonSerializer(serializer, JsonGlobals.dString);
|
|
}
|
|
else
|
|
{
|
|
serializer = RecreateDataContractJsonSerializer(serializer, JsonGlobals.rootString);
|
|
}
|
|
|
|
object graph = parameters[part.Description.Index];
|
|
try
|
|
{
|
|
serializer.WriteObject(writer, graph);
|
|
}
|
|
catch (SerializationException sx)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorSerializingParameter, part.Description.Namespace, part.Description.Name, sx.Message), sx));
|
|
}
|
|
}
|
|
if (useAspNetJsonWrapper && !isRequest)
|
|
{
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
void SerializeBody(XmlDictionaryWriter writer, object returnValue, object[] parameters, bool isRequest)
|
|
{
|
|
if (writer == null)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("writer"));
|
|
}
|
|
|
|
if (parameters == null)
|
|
{
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parameters"));
|
|
}
|
|
|
|
MessageInfo messageInfo;
|
|
if (isRequest)
|
|
{
|
|
messageInfo = requestMessageInfo;
|
|
}
|
|
else
|
|
{
|
|
messageInfo = replyMessageInfo;
|
|
}
|
|
|
|
if (messageInfo.WrapperName != null)
|
|
{
|
|
if (WebHttpBehavior.TrySetupJavascriptCallback(callbackParameterName) != null)
|
|
{
|
|
writer.WriteStartElement(JsonGlobals.rootString);
|
|
}
|
|
else
|
|
{
|
|
writer.WriteStartElement(messageInfo.WrapperName, messageInfo.WrapperNamespace);
|
|
}
|
|
writer.WriteAttributeString(JsonGlobals.typeString, JsonGlobals.objectString);
|
|
}
|
|
|
|
if (messageInfo.ReturnPart != null)
|
|
{
|
|
SerializeParameter(writer, messageInfo.ReturnPart, returnValue);
|
|
}
|
|
SerializeParameters(writer, messageInfo.BodyParts, parameters);
|
|
|
|
if (messageInfo.WrapperName != null)
|
|
{
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
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 System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
|
|
System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBodyErrorSerializingParameter, part.Description.Namespace, part.Description.Name, sx.Message), sx));
|
|
}
|
|
}
|
|
|
|
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 ValidateTypeObjectAttribute(XmlDictionaryReader reader, bool isRequest)
|
|
{
|
|
MessageInfo messageInfo = isRequest ? requestMessageInfo : replyMessageInfo;
|
|
if (messageInfo.WrapperName != null)
|
|
{
|
|
if (!IsStartElement(reader, messageInfo.WrapperName, messageInfo.WrapperNamespace))
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBody, messageInfo.WrapperName, messageInfo.WrapperNamespace, reader.NodeType, reader.Name, reader.NamespaceURI)));
|
|
}
|
|
string typeAttribute = reader.GetAttribute(JsonGlobals.typeString);
|
|
if (!typeAttribute.Equals(JsonGlobals.objectString, StringComparison.Ordinal))
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
XmlObjectSerializer.CreateSerializationException(SR2.GetString(SR2.JsonFormatterExpectedAttributeObject, typeAttribute)));
|
|
}
|
|
}
|
|
}
|
|
|
|
void VerifyIsStartElement(XmlDictionaryReader reader, string elementName)
|
|
{
|
|
bool foundElement = false;
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (IsStartElement(reader, elementName))
|
|
{
|
|
foundElement = true;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
OperationFormatter.TraceAndSkipElement(reader);
|
|
}
|
|
}
|
|
if (!foundElement)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBody, elementName, string.Empty, reader.NodeType, reader.Name, reader.NamespaceURI)));
|
|
}
|
|
}
|
|
|
|
void VerifyIsStartElement(XmlDictionaryReader reader, XmlDictionaryString elementName, XmlDictionaryString elementNamespace)
|
|
{
|
|
bool foundElement = false;
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (IsStartElement(reader, elementName, elementNamespace))
|
|
{
|
|
foundElement = true;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
OperationFormatter.TraceAndSkipElement(reader);
|
|
}
|
|
}
|
|
if (!foundElement)
|
|
{
|
|
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(System.ServiceModel.SR.GetString(System.ServiceModel.SR.SFxInvalidMessageBody, elementName, elementNamespace, reader.NodeType, reader.Name, reader.NamespaceURI)));
|
|
}
|
|
}
|
|
|
|
void WriteVoidReturn(XmlDictionaryWriter writer)
|
|
{
|
|
writer.WriteStartElement(JsonGlobals.dString);
|
|
writer.WriteAttributeString(JsonGlobals.typeString, JsonGlobals.nullString);
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
}
|