private void DeserializeParameters(XmlDictionaryReader reader, PartInfo[] parts, object[] parameters)
{
if (parts.Length != parameters.Length)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ArgumentException(SR.Format(SR.SFxParameterCountMismatch, "parts", parts.Length, "parameters", parameters.Length), "parameters"));
}
int nextPartIndex = 0;
while (reader.IsStartElement())
{
for (int i = nextPartIndex; i < parts.Length; i++)
{
PartInfo part = parts[i];
if (IsPartElement(reader, part))
{
parameters[part.Description.Index] = DeserializeParameter(reader, parts[i]);
nextPartIndex = i + 1;
}
else
{
parameters[part.Description.Index] = null;
}
}
if (reader.IsStartElement())
{
OperationFormatter.TraceAndSkipElement(reader);
}
}
}
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
lock (ThisLock)
{
OperationFormatter.SerializeBodyContents(writer, _version, _parameters, _returnValue, _isRequest);
}
}
internal object GetContentAndSaveHeaderAttributes(object parameterValue, MessageHeaderDescription headerDescription)
{
bool flag;
bool flag2;
string str;
if (parameterValue == null)
{
return(null);
}
if (headerDescription.Multiple)
{
object[] objArray = (object[])parameterValue;
MessageHeader <object>[] headerArray = new MessageHeader <object> [objArray.Length];
Array array = Array.CreateInstance(headerDescription.Type, objArray.Length);
for (int i = 0; i < array.Length; i++)
{
array.SetValue(OperationFormatter.GetContentOfMessageHeaderOfT(headerDescription, objArray[i], out flag, out flag2, out str), i);
headerArray[i] = new MessageHeader <object>(null, flag, str, flag2);
}
this.attributes[headerDescription.Index] = headerArray;
return(array);
}
object obj2 = OperationFormatter.GetContentOfMessageHeaderOfT(headerDescription, parameterValue, out flag, out flag2, out str);
this.attributes[headerDescription.Index] = new MessageHeader <object>(null, flag, str, flag2);
return(obj2);
}
private void DeserializeParameters(XmlDictionaryReader reader, PartInfo[] parts, object[] parameters)
{
if (parts.Length != parameters.Length)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("SFxParameterCountMismatch", new object[] { "parts", parts.Length, "parameters", parameters.Length }), "parameters"));
}
int num = 0;
while (reader.IsStartElement())
{
for (int i = num; i < parts.Length; i++)
{
PartInfo part = parts[i];
if (this.IsPartElement(reader, part))
{
parameters[part.Description.Index] = this.DeserializeParameter(reader, parts[i]);
num = i + 1;
}
else
{
parameters[part.Description.Index] = null;
}
}
if (reader.IsStartElement())
{
OperationFormatter.TraceAndSkipElement(reader);
}
}
}
private 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);
}
}
}
internal SerializeBodyContentsAsyncResult(OperationFormatter operationFormatter, XmlDictionaryWriter writer, MessageVersion version, object[] parameters,
object returnValue, bool isRequest, AsyncCallback callback, object state)
: base(callback, state)
{
bool completeSelf = true;
MessageDescription messageDescription;
StreamFormatter streamFormatter;
operationFormatter.SetupStreamAndMessageDescription(isRequest, out streamFormatter, out messageDescription);
if (streamFormatter != null)
{
_streamFormatter = streamFormatter;
IAsyncResult result = streamFormatter.BeginSerialize(writer, parameters, returnValue, PrepareAsyncCompletion(s_handleEndSerializeBodyContents), this);
completeSelf = SyncContinue(result);
}
else
{
operationFormatter.SerializeBody(writer, version, operationFormatter.RequestAction, messageDescription, returnValue, parameters, isRequest);
completeSelf = true;
}
if (completeSelf)
{
Complete(true);
}
}
protected override object DeserializeBody(XmlDictionaryReader reader, MessageVersion version, string action, MessageDescription messageDescription, object[] parameters, bool isRequest)
{
MessageInfo requestMessageInfo;
PartInfo info2;
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 (isRequest)
{
requestMessageInfo = this.requestMessageInfo;
}
else
{
requestMessageInfo = this.replyMessageInfo;
}
if (requestMessageInfo.WrapperName != null)
{
if (!reader.IsStartElement(requestMessageInfo.WrapperName, requestMessageInfo.WrapperNamespace))
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(System.ServiceModel.SR.GetString("SFxInvalidMessageBody", new object[] { requestMessageInfo.WrapperName, requestMessageInfo.WrapperNamespace, reader.NodeType, reader.Name, reader.NamespaceURI })));
}
bool isEmptyElement = reader.IsEmptyElement;
reader.Read();
if (isEmptyElement)
{
return(null);
}
}
object obj2 = null;
if (requestMessageInfo.ReturnPart == null)
{
goto Label_010E;
}
Label_00DC:
info2 = requestMessageInfo.ReturnPart;
if (info2.Serializer.IsStartObject(reader))
{
obj2 = this.DeserializeParameter(reader, info2, isRequest);
}
else if (reader.IsStartElement())
{
OperationFormatter.TraceAndSkipElement(reader);
goto Label_00DC;
}
Label_010E:
this.DeserializeParameters(reader, requestMessageInfo.BodyParts, parameters, isRequest);
if (requestMessageInfo.WrapperName != null)
{
reader.ReadEndElement();
}
return(obj2);
}
public void DeserializeRequest(Message message, object[] parameters)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
if (parameters == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException("parameters"), message);
}
try
{
if (_requestDescription.IsTypedMessage)
{
object typeMessageInstance = CreateTypedMessageInstance(_requestDescription.MessageType);
TypedMessageParts typedMessageParts = new TypedMessageParts(typeMessageInstance, _requestDescription);
object[] parts = new object[typedMessageParts.Count];
GetPropertiesFromMessage(message, _requestDescription, parts);
GetHeadersFromMessage(message, _requestDescription, parts, true /*isRequest*/);
DeserializeBodyContents(message, parts, true /*isRequest*/);
// copy values into the actual field/properties
typedMessageParts.SetTypedMessageParts(parts);
parameters[0] = typeMessageInstance;
}
else
{
GetPropertiesFromMessage(message, _requestDescription, parameters);
GetHeadersFromMessage(message, _requestDescription, parameters, true /*isRequest*/);
DeserializeBodyContents(message, parameters, true /*isRequest*/);
}
}
catch (XmlException xe)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
OperationFormatter.CreateDeserializationFailedFault(
SR.Format(SR.SFxErrorDeserializingRequestBodyMore, _operationName, xe.Message),
xe));
}
catch (FormatException fe)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
OperationFormatter.CreateDeserializationFailedFault(
SR.Format(SR.SFxErrorDeserializingRequestBodyMore, _operationName, fe.Message),
fe));
}
catch (SerializationException se)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
SR.Format(SR.SFxErrorDeserializingRequestBodyMore, _operationName, se.Message),
se));
}
}
public OperationFormatterBodyWriter(OperationFormatter operationFormatter, MessageVersion version,
object[] parameters, object returnValue, bool isRequest)
: base(AreParametersBuffered(isRequest, operationFormatter))
{
_parameters = parameters;
_returnValue = returnValue;
_isRequest = isRequest;
_operationFormatter = operationFormatter;
_version = version;
}
public PrimitiveOperationFormatter(OperationDescription description, bool isRpc)
{
if (description == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
}
OperationFormatter.Validate(description, isRpc, false /*isEncoded*/);
this.operation = description;
#pragma warning suppress 56506 // Microsoft, OperationDescription.Messages never be null
this.requestMessage = description.Messages[0];
if (description.Messages.Count == 2)
{
this.responseMessage = description.Messages[1];
}
int stringCount = 3 + requestMessage.Body.Parts.Count;
if (responseMessage != null)
{
stringCount += 2 + responseMessage.Body.Parts.Count;
}
XmlDictionary dictionary = new XmlDictionary(stringCount * 2);
xsiNilLocalName = dictionary.Add("nil");
xsiNilNamespace = dictionary.Add(System.Xml.Schema.XmlSchema.InstanceNamespace);
OperationFormatter.GetActions(description, dictionary, out this.action, out this.replyAction);
if (requestMessage.Body.WrapperName != null)
{
requestWrapperName = AddToDictionary(dictionary, requestMessage.Body.WrapperName);
requestWrapperNamespace = AddToDictionary(dictionary, requestMessage.Body.WrapperNamespace);
}
requestParts = AddToDictionary(dictionary, requestMessage.Body.Parts, isRpc);
if (responseMessage != null)
{
if (responseMessage.Body.WrapperName != null)
{
responseWrapperName = AddToDictionary(dictionary, responseMessage.Body.WrapperName);
responseWrapperNamespace = AddToDictionary(dictionary, responseMessage.Body.WrapperNamespace);
}
responseParts = AddToDictionary(dictionary, responseMessage.Body.Parts, isRpc);
if (responseMessage.Body.ReturnValue != null && responseMessage.Body.ReturnValue.Type != typeof(void))
{
returnPart = AddToDictionary(dictionary, responseMessage.Body.ReturnValue, isRpc);
}
}
}
public PrimitiveOperationFormatter(OperationDescription description, bool isRpc)
{
if (description == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
}
OperationFormatter.Validate(description, isRpc, false /*isEncoded*/);
_operation = description;
_requestMessage = description.Messages[0];
if (description.Messages.Count == 2)
{
_responseMessage = description.Messages[1];
}
int stringCount = 3 + _requestMessage.Body.Parts.Count;
if (_responseMessage != null)
{
stringCount += 2 + _responseMessage.Body.Parts.Count;
}
XmlDictionary dictionary = new XmlDictionary(stringCount * 2);
_xsiNilLocalName = dictionary.Add("nil");
_xsiNilNamespace = dictionary.Add(EndpointAddressProcessor.XsiNs);
OperationFormatter.GetActions(description, dictionary, out _action, out _replyAction);
if (_requestMessage.Body.WrapperName != null)
{
_requestWrapperName = AddToDictionary(dictionary, _requestMessage.Body.WrapperName);
_requestWrapperNamespace = AddToDictionary(dictionary, _requestMessage.Body.WrapperNamespace);
}
_requestParts = AddToDictionary(dictionary, _requestMessage.Body.Parts, isRpc);
if (_responseMessage != null)
{
if (_responseMessage.Body.WrapperName != null)
{
_responseWrapperName = AddToDictionary(dictionary, _responseMessage.Body.WrapperName);
_responseWrapperNamespace = AddToDictionary(dictionary, _responseMessage.Body.WrapperNamespace);
}
_responseParts = AddToDictionary(dictionary, _responseMessage.Body.Parts, isRpc);
if (_responseMessage.Body.ReturnValue != null && _responseMessage.Body.ReturnValue.Type != typeof(void))
{
_returnPart = AddToDictionary(dictionary, _responseMessage.Body.ReturnValue, isRpc);
}
}
}
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);
}
public void DeserializeRequest(Message message, object[] parameters)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(message)));
}
if (parameters == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(parameters)), message);
}
try
{
if (message.IsEmpty)
{
if (_requestWrapperName == null)
{
return;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.SFxInvalidMessageBodyEmptyMessage));
}
XmlDictionaryReader bodyReader = message.GetReaderAtBodyContents();
using (bodyReader)
{
DeserializeRequest(bodyReader, parameters);
message.ReadFromBodyContentsToEnd(bodyReader);
}
}
catch (XmlException xe)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
OperationFormatter.CreateDeserializationFailedFault(
SR.Format(SR.SFxErrorDeserializingRequestBodyMore, _operation.Name, xe.Message),
xe));
}
catch (FormatException fe)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
OperationFormatter.CreateDeserializationFailedFault(
SR.Format(SR.SFxErrorDeserializingRequestBodyMore, _operation.Name, fe.Message),
fe));
}
catch (SerializationException se)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
SR.Format(SR.SFxErrorDeserializingRequestBodyMore, _operation.Name, se.Message),
se));
}
}
public OperationFormatterHeader(OperationFormatter operationFormatter, MessageVersion version, string name, string ns, bool mustUnderstand, string actor, bool relay)
{
this.operationFormatter = operationFormatter;
this.version = version;
if (actor != null)
{
innerHeader = MessageHeader.CreateHeader(name, ns, null /*headerValue*/, mustUnderstand, actor, relay);
}
else
{
innerHeader = MessageHeader.CreateHeader(name, ns, null /*headerValue*/, mustUnderstand, "", relay);
}
}
private object DeserializeResponse(XmlDictionaryReader reader, object[] parameters)
{
if (_responseWrapperName != null)
{
if (!reader.IsStartElement(_responseWrapperName, _responseWrapperNamespace))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.Format(SR.SFxInvalidMessageBody, _responseWrapperName, _responseWrapperNamespace, reader.NodeType, reader.Name, reader.NamespaceURI)));
}
bool isEmptyElement = reader.IsEmptyElement;
reader.Read();
if (isEmptyElement)
{
return(null);
}
}
object returnValue = null;
if (_returnPart != null)
{
while (true)
{
if (IsPartElement(reader, _returnPart))
{
returnValue = DeserializeParameter(reader, _returnPart);
break;
}
if (!reader.IsStartElement())
{
break;
}
if (IsPartElements(reader, _responseParts))
{
break;
}
OperationFormatter.TraceAndSkipElement(reader);
}
}
DeserializeParameters(reader, _responseParts, parameters);
if (_responseWrapperName != null)
{
reader.ReadEndElement();
}
return(returnValue);
}
private static MessagePartDescription GetStreamPart(MessageDescription messageDescription)
{
if (OperationFormatter.IsValidReturnValue(messageDescription.Body.ReturnValue))
{
if ((messageDescription.Body.Parts.Count == 0) && (messageDescription.Body.ReturnValue.Type == typeof(Stream)))
{
return(messageDescription.Body.ReturnValue);
}
}
else if ((messageDescription.Body.Parts.Count == 1) && (messageDescription.Body.Parts[0].Type == typeof(Stream)))
{
return(messageDescription.Body.Parts[0]);
}
return(null);
}
internal OnWriteBodyContentsAsyncResult(OperationFormatterBodyWriter operationFormatterBodyWriter, XmlDictionaryWriter writer, AsyncCallback callback, object state)
: base(callback, state)
{
bool completeSelf = true;
_operationFormatter = operationFormatterBodyWriter.OperationFormatter;
IAsyncResult result = _operationFormatter.BeginSerializeBodyContents(writer, operationFormatterBodyWriter._version,
operationFormatterBodyWriter._parameters, operationFormatterBodyWriter._returnValue, operationFormatterBodyWriter._isRequest,
PrepareAsyncCompletion(s_handleEndOnWriteBodyContents), this);
completeSelf = SyncContinue(result);
if (completeSelf)
{
Complete(true);
}
}
private MessageInfo CreateMessageInfo(DataContractFormatAttribute dataContractFormatAttribute, MessageDescription messageDescription, DataContractSerializerOperationBehavior serializerFactory)
{
if (messageDescription.IsUntypedMessage)
{
return(null);
}
MessageInfo info = new MessageInfo();
MessageBodyDescription body = messageDescription.Body;
if (body.WrapperName != null)
{
info.WrapperName = base.AddToDictionary(body.WrapperName);
info.WrapperNamespace = base.AddToDictionary(body.WrapperNamespace);
}
MessagePartDescriptionCollection parts = body.Parts;
info.BodyParts = new PartInfo[parts.Count];
for (int i = 0; i < parts.Count; i++)
{
info.BodyParts[i] = this.CreatePartInfo(parts[i], dataContractFormatAttribute.Style, serializerFactory);
}
if (OperationFormatter.IsValidReturnValue(messageDescription.Body.ReturnValue))
{
info.ReturnPart = this.CreatePartInfo(messageDescription.Body.ReturnValue, dataContractFormatAttribute.Style, serializerFactory);
}
info.HeaderDescriptionTable = new OperationFormatter.MessageHeaderDescriptionTable();
info.HeaderParts = new PartInfo[messageDescription.Headers.Count];
for (int j = 0; j < messageDescription.Headers.Count; j++)
{
MessageHeaderDescription message = messageDescription.Headers[j];
if (message.IsUnknownHeaderCollection)
{
info.UnknownHeaderDescription = message;
}
else
{
this.ValidateDataContractType(message.Type);
info.HeaderDescriptionTable.Add(message.Name, message.Namespace, message);
}
info.HeaderParts[j] = this.CreatePartInfo(message, OperationFormatStyle.Document, serializerFactory);
}
info.AnyHeaders = (info.UnknownHeaderDescription != null) || (info.HeaderDescriptionTable.Count > 0);
return(info);
}
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;
}
}
}
public PrimitiveOperationFormatter(OperationDescription description, bool isRpc)
{
if (description == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
}
OperationFormatter.Validate(description, isRpc, false);
this.operation = description;
this.requestMessage = description.Messages[0];
if (description.Messages.Count == 2)
{
this.responseMessage = description.Messages[1];
}
int num = 3 + this.requestMessage.Body.Parts.Count;
if (this.responseMessage != null)
{
num += 2 + this.responseMessage.Body.Parts.Count;
}
XmlDictionary dictionary = new XmlDictionary(num * 2);
this.xsiNilLocalName = dictionary.Add("nil");
this.xsiNilNamespace = dictionary.Add("http://www.w3.org/2001/XMLSchema-instance");
OperationFormatter.GetActions(description, dictionary, out this.action, out this.replyAction);
if (this.requestMessage.Body.WrapperName != null)
{
this.requestWrapperName = AddToDictionary(dictionary, this.requestMessage.Body.WrapperName);
this.requestWrapperNamespace = AddToDictionary(dictionary, this.requestMessage.Body.WrapperNamespace);
}
this.requestParts = AddToDictionary(dictionary, this.requestMessage.Body.Parts, isRpc);
if (this.responseMessage != null)
{
if (this.responseMessage.Body.WrapperName != null)
{
this.responseWrapperName = AddToDictionary(dictionary, this.responseMessage.Body.WrapperName);
this.responseWrapperNamespace = AddToDictionary(dictionary, this.responseMessage.Body.WrapperNamespace);
}
this.responseParts = AddToDictionary(dictionary, this.responseMessage.Body.Parts, isRpc);
if ((this.responseMessage.Body.ReturnValue != null) && (this.responseMessage.Body.ReturnValue.Type != typeof(void)))
{
this.returnPart = AddToDictionary(dictionary, this.responseMessage.Body.ReturnValue, isRpc);
}
}
}
private void SerializeBody(XmlDictionaryWriter writer, MessageVersion version, XmlSerializer serializer, MessagePartDescription returnPart, MessagePartDescriptionCollection bodyParts, object returnValue, object[] parameters)
{
if (serializer != null)
{
bool flag = OperationFormatter.IsValidReturnValue(returnPart);
object[] o = new object[bodyParts.Count + (flag ? 1 : 0)];
int num = 0;
if (flag)
{
o[num++] = returnValue;
}
for (int i = 0; i < bodyParts.Count; i++)
{
o[num++] = parameters[bodyParts[i].Index];
}
string encodingStyle = this.isEncoded ? GetEncoding(version.Envelope) : null;
serializer.Serialize(writer, o, null, encodingStyle);
}
}
private object DeserializeBody(XmlDictionaryReader reader, MessageVersion version, XmlSerializer serializer, MessagePartDescription returnPart, MessagePartDescriptionCollection bodyParts, object[] parameters, bool isRequest)
{
object obj3;
try
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("reader"));
}
if (parameters == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("parameters"));
}
object obj2 = null;
if (serializer == null)
{
return(null);
}
if (reader.NodeType == XmlNodeType.EndElement)
{
return(null);
}
object[] objArray = (object[])serializer.Deserialize(reader, this.isEncoded ? GetEncoding(version.Envelope) : null);
int num = 0;
if (OperationFormatter.IsValidReturnValue(returnPart))
{
obj2 = objArray[num++];
}
for (int i = 0; i < bodyParts.Count; i++)
{
parameters[bodyParts[i].Index] = objArray[num++];
}
obj3 = obj2;
}
catch (InvalidOperationException exception)
{
string name = isRequest ? "SFxErrorDeserializingRequestBody" : "SFxErrorDeserializingReplyBody";
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString(name, new object[] { base.OperationName }), exception));
}
return(obj3);
}
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)));
}
}
private void AddMessageHeaderForParameter(MessageHeaders headers, PartInfo headerPart, MessageVersion messageVersion, object parameterValue, bool isXmlElement)
{
string str;
bool flag;
bool flag2;
MessageHeaderDescription headerDescription = (MessageHeaderDescription)headerPart.Description;
object headerValue = OperationFormatter.GetContentOfMessageHeaderOfT(headerDescription, parameterValue, out flag, out flag2, out str);
if (isXmlElement)
{
if (headerValue != null)
{
XmlElement element = (XmlElement)headerValue;
headers.Add(new OperationFormatter.XmlElementMessageHeader(this, messageVersion, element.LocalName, element.NamespaceURI, flag, str, flag2, element));
}
}
else
{
headers.Add(new DataContractSerializerMessageHeader(headerPart, headerValue, flag, str, flag2));
}
}
private object DeserializeResponse(XmlDictionaryReader reader, object[] parameters)
{
if (this.responseWrapperName != null)
{
if (!reader.IsStartElement(this.responseWrapperName, this.responseWrapperNamespace))
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(System.ServiceModel.SR.GetString("SFxInvalidMessageBody", new object[] { this.responseWrapperName, this.responseWrapperNamespace, reader.NodeType, reader.Name, reader.NamespaceURI })));
}
bool isEmptyElement = reader.IsEmptyElement;
reader.Read();
if (isEmptyElement)
{
return(null);
}
}
object obj2 = null;
if (this.returnPart == null)
{
goto Label_00CB;
}
Label_008D:
if (this.IsPartElement(reader, this.returnPart))
{
obj2 = this.DeserializeParameter(reader, this.returnPart);
}
else if (reader.IsStartElement() && !this.IsPartElements(reader, this.responseParts))
{
OperationFormatter.TraceAndSkipElement(reader);
goto Label_008D;
}
Label_00CB:
this.DeserializeParameters(reader, this.responseParts, parameters);
if (this.responseWrapperName != null)
{
reader.ReadEndElement();
}
return(obj2);
}
private object DeserializeParameterPart(XmlDictionaryReader reader, PartInfo part, bool isRequest)
{
object val;
try
{
val = part.ReadObject(reader);
}
catch (InvalidOperationException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e));
}
catch (InvalidDataContractException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(
SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameter, part.Description.Namespace, part.Description.Name), e));
}
catch (FormatException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
OperationFormatter.CreateDeserializationFailedFault(
SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
part.Description.Namespace, part.Description.Name, e.Message),
e));
}
catch (SerializationException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
OperationFormatter.CreateDeserializationFailedFault(
SR.Format(SR.SFxInvalidMessageBodyErrorDeserializingParameterMore,
part.Description.Namespace, part.Description.Name, e.Message),
e));
}
return(val);
}
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);
}
public XmlElementMessageHeader(OperationFormatter operationFormatter, MessageVersion version, string name, string ns, bool mustUnderstand, string actor, bool relay, XmlElement headerValue) :
base(operationFormatter, version, name, ns, mustUnderstand, actor, relay)
{
this.headerValue = headerValue;
}
internal XmlMessageConverter(OperationFormatter formatter)
{
this.formatter = formatter;
}
internal void SetHeaderDescriptionTable(OperationFormatter.MessageHeaderDescriptionTable headerDescriptionTable)
{
_headerDescriptionTable = headerDescriptionTable;
}
private static bool AreParametersBuffered(bool isRequest, OperationFormatter operationFormatter)
{
StreamFormatter streamFormatter = isRequest ? operationFormatter.requestStreamFormatter : operationFormatter.replyStreamFormatter;
return(streamFormatter == null);
}
private OperationFormatterMessage(MessageHeaders headers, KeyValuePair <string, object>[] properties, OperationFormatterBodyWriter bodyWriter)
: base(headers, properties, bodyWriter)
{
_operationFormatter = bodyWriter.OperationFormatter;
}
