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