private static bool GetRemoteEnlistmentId(EndpointAddress address, out Guid remoteEnlistmentId) { AddressHeaderCollection headers = address.Headers; if (headers.Count == 1) { AddressHeader header = headers.FindHeader("Enlistment", "http://schemas.microsoft.com/ws/2006/02/transactions"); if (header != null) { XmlDictionaryReader addressHeaderReader = header.GetAddressHeaderReader(); XmlDictionaryReader reader2 = addressHeaderReader; try { ControlProtocol protocol; EnlistmentHeader.ReadFrom(addressHeaderReader, out remoteEnlistmentId, out protocol); return(protocol == ControlProtocol.Durable2PC); } catch (InvalidEnlistmentHeaderException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Information); } finally { if (reader2 != null) { reader2.Dispose(); } } } } remoteEnlistmentId = Guid.Empty; return(false); }
protected override void OnWriteStartAddressHeader(XmlDictionaryWriter writer) { XmlDictionaryReader reader = GetAddressHeaderReader(); writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); writer.WriteAttributes(reader, false); reader.Dispose(); }
protected override void Dispose(bool isDisposing) { _message.Close(); if (_reader != null) { _reader.Dispose(); _reader = null; } base.Dispose(isDisposing); }
public static MessageFault CreateFault(Message message, int maxBufferSize) { MessageFault fault2; if (message == null) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message")); } XmlDictionaryReader readerAtBodyContents = message.GetReaderAtBodyContents(); XmlDictionaryReader reader2 = readerAtBodyContents; try { MessageFault fault; EnvelopeVersion envelope = message.Version.Envelope; if (envelope == EnvelopeVersion.Soap12) { fault = ReceivedFault.CreateFault12(readerAtBodyContents, maxBufferSize); } else if (envelope == EnvelopeVersion.Soap11) { fault = ReceivedFault.CreateFault11(readerAtBodyContents, maxBufferSize); } else { if (envelope != EnvelopeVersion.None) { throw TraceUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("EnvelopeVersionUnknown", new object[] { envelope.ToString() })), message); } fault = ReceivedFault.CreateFaultNone(readerAtBodyContents, maxBufferSize); } message.ReadFromBodyContentsToEnd(readerAtBodyContents); fault2 = fault; } catch (InvalidOperationException exception) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SFxErrorDeserializingFault"), exception)); } catch (FormatException exception2) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SFxErrorDeserializingFault"), exception2)); } catch (XmlException exception3) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SFxErrorDeserializingFault"), exception3)); } finally { if (reader2 != null) { reader2.Dispose(); } } return(fault2); }
public static List <SaveMusicList> ReadMusicListData(string folder_path) { List <SaveMusicList> objectMusic = new List <SaveMusicList>(); FileStream fs = new FileStream(folder_path, FileMode.Open); XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas()); DataContractSerializer ser = new DataContractSerializer(typeof(List <SaveMusicList>)); objectMusic = (List <SaveMusicList>)ser.ReadObject(reader, true); reader.Dispose(); fs.Dispose(); return(objectMusic); }
protected override void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion) { if (!IsMessageVersionSupported(messageVersion)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.MessageHeaderVersionNotSupported, GetType().FullName, messageVersion.ToString()), "version")); } XmlDictionaryReader reader = GetHeaderReader(); writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); writer.WriteAttributes(reader, false); reader.Dispose(); }
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion) { XmlDictionaryReader reader = GetHeaderReader(); reader.ReadStartElement(); while (reader.NodeType != XmlNodeType.EndElement) { writer.WriteNode(reader, false); } reader.ReadEndElement(); reader.Dispose(); }
/// <summary> /// Extracts the img values from the JSON string /// </summary> /// <param name="jsonResponse">JSON string</param> /// <returns></returns> public static Dictionary <string, string> GetQRimage(string jsonResponse) { Dictionary <string, string> imgs = new Dictionary <string, string>(); XmlDictionaryReader reader = JsonReaderWriterFactory.CreateJsonReader(Encoding.ASCII.GetBytes(jsonResponse), new XmlDictionaryReaderQuotas()); XDocument xml = XDocument.Load(reader); reader.Dispose(); foreach (XElement element in xml.Descendants("img")) { imgs.Add(element.Parent.Name.ToString(), element.Value); } return(imgs); }
bool InferHasDetail(XmlBuffer detail) { bool hasDetail = false; if (detail != null) { XmlDictionaryReader reader = detail.GetReader(0); if (!reader.IsEmptyElement && reader.Read()) // check if the detail element contains data { hasDetail = (reader.MoveToContent() != XmlNodeType.EndElement); } reader.Dispose(); } return(hasDetail); }
/// <summary> /// Deserialize an object from JSON file. /// </summary> /// <param name="file">Path of the file to deserialize.</param> /// <returns>Object fill with file informations.</returns> public static T JsonDeserialize(string file) { FileStream fs = new FileStream(file, FileMode.Open); XmlDictionaryReader reader = JsonReaderWriterFactory.CreateJsonReader(fs, new XmlDictionaryReaderQuotas()); DataContractSerializer ser = new DataContractSerializer(typeof(T)); // Deserialize the data and read it from the instance. T result = ser.ReadObject(reader, true) as T; reader.Close(); reader.Dispose(); fs.Close(); fs.Dispose(); return(result); }
public void WriteTo(int sectionIndex, XmlWriter writer) { if (_bufferState != BufferState.Reading) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateInvalidStateException()); } XmlDictionaryReader reader = GetReader(sectionIndex); try { writer.WriteNode(reader, false); } finally { reader.Dispose(); } }
public static OleTxTransactionHeader ReadFrom(Message message) { int num; OleTxTransactionHeader header; try { num = message.Headers.FindHeader("OleTxTransaction", "http://schemas.microsoft.com/ws/2006/02/tx/oletx"); } catch (MessageHeaderException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TransactionException(System.ServiceModel.SR.GetString("OleTxHeaderCorrupt"), exception)); } if (num < 0) { return(null); } XmlDictionaryReader readerAtHeader = message.Headers.GetReaderAtHeader(num); XmlDictionaryReader reader2 = readerAtHeader; try { header = ReadFrom(readerAtHeader); } catch (XmlException exception2) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Error); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TransactionException(System.ServiceModel.SR.GetString("OleTxHeaderCorrupt"), exception2)); } finally { if (reader2 != null) { reader2.Dispose(); } } MessageHeaderInfo headerInfo = message.Headers[num]; if (!message.Headers.UnderstoodHeaders.Contains(headerInfo)) { message.Headers.UnderstoodHeaders.Add(headerInfo); } return(header); }
public static WsatRegistrationHeader ReadFrom(Message message) { int num; WsatRegistrationHeader header; try { num = message.Headers.FindHeader("RegisterInfo", "http://schemas.microsoft.com/ws/2006/02/transactions"); } catch (MessageHeaderException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); return(null); } if (num < 0) { return(null); } XmlDictionaryReader readerAtHeader = message.Headers.GetReaderAtHeader(num); XmlDictionaryReader reader2 = readerAtHeader; try { header = ReadFrom(readerAtHeader); } catch (XmlException exception2) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception2, TraceEventType.Error); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidEnlistmentHeaderException(exception2.Message, exception2)); } finally { if (reader2 != null) { reader2.Dispose(); } } MessageHeaderInfo headerInfo = message.Headers[num]; if (!message.Headers.UnderstoodHeaders.Contains(headerInfo)) { message.Headers.UnderstoodHeaders.Add(headerInfo); } return(header); }
/// <summary> /// Get JSON information from a defined node /// </summary> /// <param name="jsonResponse">JSON string</param> /// <param name="nodename">node name of the JSON field</param> /// <returns>returns the value (inner text) from the defined node</returns> public static string GetJsonNode(string jsonResponse, string nodename) { try { XmlDictionaryReader reader = JsonReaderWriterFactory.CreateJsonReader(Encoding.ASCII.GetBytes(jsonResponse), new XmlDictionaryReaderQuotas()); XDocument xml = XDocument.Load(reader); reader.Dispose(); return(xml.Descendants(nodename).Single().Value); } #pragma warning disable CA1031 // Do not catch general exception types catch (Exception ex) #pragma warning restore CA1031 // Do not catch general exception types { #if DEBUG Debug.WriteLine($"{debugPrefix} GetJsonNode() exception: {ex.Message}"); #endif LogEvent($"GetJsonNode() exception: {ex.Message}", EventLogEntryType.Error); return(""); } }
public static object LoadFromFile(Type type, string filename) { object r = null; try { DataContractSerializer ser = new DataContractSerializer(type); FileStream stream = new FileStream(ApplicationData.Current.LocalFolder.Path + "\\" + filename, FileMode.Open); XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(stream, new XmlDictionaryReaderQuotas()); r = ser.ReadObject(reader, true); reader.Dispose(); stream.Dispose(); } catch (Exception e) { System.Diagnostics.Debug.WriteLine(e.Message + "\n" + e.Source); } return(r); }
private void LoadFontSettings() { FileStream fs = null; XmlDictionaryReader reader = null; try { fs = new FileStream("settings.xml", FileMode.Open); XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas(); reader = XmlDictionaryReader.CreateTextReader(fs, quotas); DataContractSerializer ser = new DataContractSerializer(typeof(Settings)); Settings fontSettings = (Settings)ser.ReadObject(reader, true); LeftListView.Font = new Font(FontFamily.GenericSansSerif, fontSettings.FontSize); LeftListView.ForeColor = fontSettings.FontColor; RightListView.Font = new Font(FontFamily.GenericSansSerif, fontSettings.FontSize); RightListView.ForeColor = fontSettings.FontColor; } catch (System.Xml.XmlException) { MessageBox.Show("Ошибка при десериализации!"); } catch (System.IO.FileNotFoundException) { MessageBox.Show("Файл не найден!"); } catch (System.Runtime.Serialization.SerializationException) { MessageBox.Show("Файл поврежден и не может быть открыт!"); } finally { if (reader != null) { reader.Dispose(); } fs.Close(); } }
protected override void ReturnXmlReader(XmlDictionaryReader xmlReader) { Contract.Assert(xmlReader != null, "xmlReader MUST NOT be null"); xmlReader.Dispose(); }
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.Dispose(); } 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.Dispose(); } } } 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)); } }
private async Task ProcessOperation(HttpContext httpContext, IServiceProvider serviceProvider) { Message responseMessage; //Reload the body to ensure we have the full message var memoryStream = new MemoryStream((int)httpContext.Request.ContentLength.GetValueOrDefault(1024)); await httpContext.Request.Body.CopyToAsync(memoryStream).ConfigureAwait(false); memoryStream.Seek(0, SeekOrigin.Begin); httpContext.Request.Body = memoryStream; //Return metadata if no request, provided this is a GET request if (httpContext.Request.Body.Length == 0 && httpContext.Request.Method?.ToLower() == "get") { if (_options.WsdlFileOptions != null) { await ProcessMetaFromFile(httpContext); } else { await ProcessMeta(httpContext); } return; } // Get the encoder based on Content Type var messageEncoder = _messageEncoders[0]; foreach (var encoder in _messageEncoders) { if (encoder.IsContentTypeSupported(httpContext.Request.ContentType)) { messageEncoder = encoder; break; } } Message requestMessage; //Get the message try { requestMessage = await ReadMessageAsync(httpContext, messageEncoder); } catch (Exception ex) { await WriteErrorResponseMessage(ex, StatusCodes.Status500InternalServerError, serviceProvider, null, messageEncoder, httpContext); return; } var messageFilters = serviceProvider.GetServices <IMessageFilter>().ToArray(); var asyncMessageFilters = serviceProvider.GetServices <IAsyncMessageFilter>().ToArray(); //Execute request message filters try { foreach (var messageFilter in messageFilters) { messageFilter.OnRequestExecuting(requestMessage); } foreach (var messageFilter in asyncMessageFilters) { await messageFilter.OnRequestExecuting(requestMessage); } } catch (Exception ex) { await WriteErrorResponseMessage(ex, StatusCodes.Status500InternalServerError, serviceProvider, requestMessage, messageEncoder, httpContext); return; } var messageInspector = serviceProvider.GetService <IMessageInspector>(); object correlationObject; try { correlationObject = messageInspector?.AfterReceiveRequest(ref requestMessage); } catch (Exception ex) { await WriteErrorResponseMessage(ex, StatusCodes.Status500InternalServerError, serviceProvider, requestMessage, messageEncoder, httpContext); return; } var messageInspector2s = serviceProvider.GetServices <IMessageInspector2>(); var correlationObjects2 = default(List <(IMessageInspector2 inspector, object correlationObject)>); try { correlationObjects2 = messageInspector2s.Select(mi => (inspector: mi, correlationObject: mi.AfterReceiveRequest(ref requestMessage, _service))).ToList(); } catch (Exception ex) { await WriteErrorResponseMessage(ex, StatusCodes.Status500InternalServerError, serviceProvider, requestMessage, messageEncoder, httpContext); return; } // for getting soapaction and parameters in (optional) body // GetReaderAtBodyContents must not be called twice in one request XmlDictionaryReader reader = null; if (!requestMessage.IsEmpty) { reader = requestMessage.GetReaderAtBodyContents(); } try { var soapAction = HeadersHelper.GetSoapAction(httpContext, reader); requestMessage.Headers.Action = soapAction; var operation = _service.Operations.FirstOrDefault(o => o.SoapAction.Equals(soapAction, StringComparison.Ordinal) || o.Name.Equals(HeadersHelper.GetTrimmedSoapAction(soapAction), StringComparison.Ordinal)); if (operation == null) { var ex = new InvalidOperationException($"No operation found for specified action: {requestMessage.Headers.Action}"); await WriteErrorResponseMessage(ex, StatusCodes.Status500InternalServerError, serviceProvider, requestMessage, messageEncoder, httpContext); return; } _logger.LogInformation($"Request for operation {operation.Contract.Name}.{operation.Name} received"); try { //Create an instance of the service class var serviceInstance = serviceProvider.GetRequiredService(_service.ServiceType); SetMessageHeadersToProperty(requestMessage, serviceInstance); // Get operation arguments from message var arguments = GetRequestArguments(requestMessage, reader, operation, httpContext); ExecuteFiltersAndTune(httpContext, serviceProvider, operation, arguments, serviceInstance); var invoker = serviceProvider.GetService <IOperationInvoker>() ?? new DefaultOperationInvoker(); var responseObject = await invoker.InvokeAsync(operation.DispatchMethod, serviceInstance, arguments); if (operation.IsOneWay) { httpContext.Response.StatusCode = (int)HttpStatusCode.Accepted; return; } var resultOutDictionary = new Dictionary <string, object>(); foreach (var parameterInfo in operation.OutParameters) { resultOutDictionary[parameterInfo.Name] = arguments[parameterInfo.Index]; } responseMessage = CreateResponseMessage( operation, responseObject, resultOutDictionary, soapAction, requestMessage, messageEncoder); httpContext.Response.ContentType = httpContext.Request.ContentType; httpContext.Response.Headers["SOAPAction"] = responseMessage.Headers.Action; correlationObjects2.ForEach(mi => mi.inspector.BeforeSendReply(ref responseMessage, _service, mi.correlationObject)); messageInspector?.BeforeSendReply(ref responseMessage, correlationObject); SetHttpResponse(httpContext, responseMessage); await WriteMessageAsync(messageEncoder, responseMessage, httpContext); } catch (Exception exception) { if (exception is TargetInvocationException targetInvocationException) { exception = targetInvocationException.InnerException; } _logger.LogError(0, exception, exception?.Message); responseMessage = await WriteErrorResponseMessage(exception, StatusCodes.Status500InternalServerError, serviceProvider, requestMessage, messageEncoder, httpContext); } } finally { reader?.Dispose(); } // Execute response message filters try { foreach (var messageFilter in messageFilters) { messageFilter.OnResponseExecuting(responseMessage); } foreach (var messageFilter in asyncMessageFilters.Reverse()) { await messageFilter.OnResponseExecuting(responseMessage); } } catch (Exception ex) { responseMessage = await WriteErrorResponseMessage(ex, StatusCodes.Status500InternalServerError, serviceProvider, requestMessage, messageEncoder, httpContext); } }
protected override void GetHeadersFromMessage(Message message, MessageDescription messageDescription, object[] parameters, bool isRequest) { try { XmlSerializer serializer; MessageHeaderDescriptionTable headerDescriptionTable; MessageHeaderDescription unknownHeaderDescription; if (isRequest) { serializer = _requestMessageInfo.HeaderSerializer; headerDescriptionTable = _requestMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = _requestMessageInfo.UnknownHeaderDescription; } else { serializer = _replyMessageInfo.HeaderSerializer; headerDescriptionTable = _replyMessageInfo.HeaderDescriptionTable; unknownHeaderDescription = _replyMessageInfo.UnknownHeaderDescription; } MessageHeaders headers = message.Headers; ArrayList unknownHeaders = null; XmlDocument xmlDoc = null; if (unknownHeaderDescription != null) { unknownHeaders = new ArrayList(); xmlDoc = new XmlDocument(); } if (serializer == null) { if (unknownHeaderDescription != null) { for (int headerIndex = 0; headerIndex < headers.Count; headerIndex++) { AddUnknownHeader(unknownHeaderDescription, unknownHeaders, xmlDoc, null /*bufferWriter*/, headers[headerIndex], headers.GetReaderAtHeader(headerIndex)); } parameters[unknownHeaderDescription.Index] = unknownHeaders.ToArray(unknownHeaderDescription.TypedHeader ? typeof(MessageHeader <XmlElement>) : typeof(XmlElement)); } return; } MemoryStream memoryStream = new MemoryStream(); XmlDictionaryWriter bufferWriter = XmlDictionaryWriter.CreateTextWriter(memoryStream); message.WriteStartEnvelope(bufferWriter); message.WriteStartHeaders(bufferWriter); MessageHeaderOfTHelper messageHeaderOfTHelper = null; for (int headerIndex = 0; headerIndex < headers.Count; headerIndex++) { MessageHeaderInfo header = headers[headerIndex]; XmlDictionaryReader headerReader = headers.GetReaderAtHeader(headerIndex); MessageHeaderDescription matchingHeaderDescription = headerDescriptionTable.Get(header.Name, header.Namespace); if (matchingHeaderDescription != null) { if (header.MustUnderstand) { headers.UnderstoodHeaders.Add(header); } if (matchingHeaderDescription.TypedHeader) { if (messageHeaderOfTHelper == null) { messageHeaderOfTHelper = new MessageHeaderOfTHelper(parameters.Length); } messageHeaderOfTHelper.SetHeaderAttributes(matchingHeaderDescription, header.MustUnderstand, header.Relay, header.Actor); } } if (matchingHeaderDescription == null && unknownHeaderDescription != null) { AddUnknownHeader(unknownHeaderDescription, unknownHeaders, xmlDoc, bufferWriter, header, headerReader); } else { bufferWriter.WriteNode(headerReader, false); } headerReader.Dispose(); } bufferWriter.WriteEndElement(); bufferWriter.WriteEndElement(); bufferWriter.Flush(); /* * XmlDocument doc = new XmlDocument(); * memoryStream.Position = 0; * doc.Load(memoryStream); * doc.Save(Console.Out); */ memoryStream.Position = 0; ArraySegment <byte> memoryBuffer; memoryStream.TryGetBuffer(out memoryBuffer); XmlDictionaryReader bufferReader = XmlDictionaryReader.CreateTextReader(memoryBuffer.Array, 0, (int)memoryStream.Length, XmlDictionaryReaderQuotas.Max); bufferReader.ReadStartElement(); bufferReader.MoveToContent(); if (!bufferReader.IsEmptyElement) { bufferReader.ReadStartElement(); object[] headerValues = (object[])serializer.Deserialize(bufferReader, _isEncoded ? GetEncoding(message.Version.Envelope) : null); int headerIndex = 0; foreach (MessageHeaderDescription headerDescription in messageDescription.Headers) { if (!headerDescription.IsUnknownHeaderCollection) { object parameterValue = headerValues[headerIndex++]; if (headerDescription.TypedHeader && parameterValue != null) { parameterValue = messageHeaderOfTHelper.CreateMessageHeader(headerDescription, parameterValue); } parameters[headerDescription.Index] = parameterValue; } } bufferReader.Dispose(); } if (unknownHeaderDescription != null) { parameters[unknownHeaderDescription.Index] = unknownHeaders.ToArray(unknownHeaderDescription.TypedHeader ? typeof(MessageHeader <XmlElement>) : typeof(XmlElement)); } } catch (InvalidOperationException e) { // all exceptions from XmlSerializer get wrapped in InvalidOperationException, // so we must be conservative and never turn this into a fault throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException( SR.Format(SR.SFxErrorDeserializingHeader, messageDescription.MessageName), e)); } }