Files
mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Channels/BinaryMessageEncoder.cs
T
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

1920 lines
72 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections.Generic;
using System.IO;
using System.Runtime;
using System.Runtime.Diagnostics;
using System.ServiceModel;
using System.ServiceModel.Diagnostics;
using System.ServiceModel.Diagnostics.Application;
using System.Text;
using System.Xml;
class BinaryMessageEncoderFactory : MessageEncoderFactory
{
const int maxPooledXmlReaderPerMessage = 2;
BinaryMessageEncoder messageEncoder;
MessageVersion messageVersion;
int maxReadPoolSize;
int maxWritePoolSize;
CompressionFormat compressionFormat;
// Double-checked locking pattern requires volatile for read/write synchronization
volatile SynchronizedPool<XmlDictionaryWriter> streamedWriterPool;
volatile SynchronizedPool<XmlDictionaryReader> streamedReaderPool;
volatile SynchronizedPool<BinaryBufferedMessageData> bufferedDataPool;
volatile SynchronizedPool<BinaryBufferedMessageWriter> bufferedWriterPool;
volatile SynchronizedPool<RecycledMessageState> recycledStatePool;
object thisLock;
int maxSessionSize;
OnXmlDictionaryReaderClose onStreamedReaderClose;
XmlDictionaryReaderQuotas readerQuotas;
XmlDictionaryReaderQuotas bufferedReadReaderQuotas;
BinaryVersion binaryVersion;
public BinaryMessageEncoderFactory(MessageVersion messageVersion, int maxReadPoolSize, int maxWritePoolSize, int maxSessionSize,
XmlDictionaryReaderQuotas readerQuotas, long maxReceivedMessageSize, BinaryVersion version, CompressionFormat compressionFormat)
{
this.messageVersion = messageVersion;
this.maxReadPoolSize = maxReadPoolSize;
this.maxWritePoolSize = maxWritePoolSize;
this.maxSessionSize = maxSessionSize;
this.thisLock = new object();
this.onStreamedReaderClose = new OnXmlDictionaryReaderClose(ReturnStreamedReader);
this.readerQuotas = new XmlDictionaryReaderQuotas();
if (readerQuotas != null)
{
readerQuotas.CopyTo(this.readerQuotas);
}
this.bufferedReadReaderQuotas = EncoderHelpers.GetBufferedReadQuotas(this.readerQuotas);
this.MaxReceivedMessageSize = maxReceivedMessageSize;
this.binaryVersion = version;
this.compressionFormat = compressionFormat;
this.messageEncoder = new BinaryMessageEncoder(this, false, 0);
}
public static IXmlDictionary XmlDictionary
{
get { return XD.Dictionary; }
}
public override MessageEncoder Encoder
{
get
{
return messageEncoder;
}
}
public override MessageVersion MessageVersion
{
get { return messageVersion; }
}
public int MaxWritePoolSize
{
get { return maxWritePoolSize; }
}
public XmlDictionaryReaderQuotas ReaderQuotas
{
get
{
return readerQuotas;
}
}
public int MaxReadPoolSize
{
get { return maxReadPoolSize; }
}
public int MaxSessionSize
{
get { return maxSessionSize; }
}
public CompressionFormat CompressionFormat
{
get { return this.compressionFormat; }
}
long MaxReceivedMessageSize
{
get;
set;
}
object ThisLock
{
get { return thisLock; }
}
SynchronizedPool<RecycledMessageState> RecycledStatePool
{
get
{
if (recycledStatePool == null)
{
lock (ThisLock)
{
if (recycledStatePool == null)
{
//running = true;
recycledStatePool = new SynchronizedPool<RecycledMessageState>(maxReadPoolSize);
}
}
}
return recycledStatePool;
}
}
public override MessageEncoder CreateSessionEncoder()
{
return new BinaryMessageEncoder(this, true, maxSessionSize);
}
XmlDictionaryWriter TakeStreamedWriter(Stream stream)
{
if (streamedWriterPool == null)
{
lock (ThisLock)
{
if (streamedWriterPool == null)
{
//running = true;
streamedWriterPool = new SynchronizedPool<XmlDictionaryWriter>(maxWritePoolSize);
}
}
}
XmlDictionaryWriter xmlWriter = streamedWriterPool.Take();
if (xmlWriter == null)
{
xmlWriter = XmlDictionaryWriter.CreateBinaryWriter(stream, binaryVersion.Dictionary, null, false);
if (TD.WritePoolMissIsEnabled())
{
TD.WritePoolMiss(xmlWriter.GetType().Name);
}
}
else
{
((IXmlBinaryWriterInitializer)xmlWriter).SetOutput(stream, binaryVersion.Dictionary, null, false);
}
return xmlWriter;
}
void ReturnStreamedWriter(XmlDictionaryWriter xmlWriter)
{
xmlWriter.Close();
streamedWriterPool.Return(xmlWriter);
}
BinaryBufferedMessageWriter TakeBufferedWriter()
{
if (bufferedWriterPool == null)
{
lock (ThisLock)
{
if (bufferedWriterPool == null)
{
//running = true;
bufferedWriterPool = new SynchronizedPool<BinaryBufferedMessageWriter>(maxWritePoolSize);
}
}
}
BinaryBufferedMessageWriter messageWriter = bufferedWriterPool.Take();
if (messageWriter == null)
{
messageWriter = new BinaryBufferedMessageWriter(binaryVersion.Dictionary);
if (TD.WritePoolMissIsEnabled())
{
TD.WritePoolMiss(messageWriter.GetType().Name);
}
}
return messageWriter;
}
void ReturnMessageWriter(BinaryBufferedMessageWriter messageWriter)
{
bufferedWriterPool.Return(messageWriter);
}
XmlDictionaryReader TakeStreamedReader(Stream stream)
{
if (streamedReaderPool == null)
{
lock (ThisLock)
{
if (streamedReaderPool == null)
{
//running = true;
streamedReaderPool = new SynchronizedPool<XmlDictionaryReader>(maxReadPoolSize);
}
}
}
XmlDictionaryReader xmlReader = streamedReaderPool.Take();
if (xmlReader == null)
{
xmlReader = XmlDictionaryReader.CreateBinaryReader(stream,
binaryVersion.Dictionary,
readerQuotas,
null,
onStreamedReaderClose);
if (TD.ReadPoolMissIsEnabled())
{
TD.ReadPoolMiss(xmlReader.GetType().Name);
}
}
else
{
((IXmlBinaryReaderInitializer)xmlReader).SetInput(stream,
binaryVersion.Dictionary,
readerQuotas,
null,
onStreamedReaderClose);
}
return xmlReader;
}
void ReturnStreamedReader(XmlDictionaryReader xmlReader)
{
streamedReaderPool.Return(xmlReader);
}
BinaryBufferedMessageData TakeBufferedData(BinaryMessageEncoder messageEncoder)
{
if (bufferedDataPool == null)
{
lock (ThisLock)
{
if (bufferedDataPool == null)
{
//running = true;
bufferedDataPool = new SynchronizedPool<BinaryBufferedMessageData>(maxReadPoolSize);
}
}
}
BinaryBufferedMessageData messageData = bufferedDataPool.Take();
if (messageData == null)
{
messageData = new BinaryBufferedMessageData(this, maxPooledXmlReaderPerMessage);
if (TD.ReadPoolMissIsEnabled())
{
TD.ReadPoolMiss(messageData.GetType().Name);
}
}
messageData.SetMessageEncoder(messageEncoder);
return messageData;
}
void ReturnBufferedData(BinaryBufferedMessageData messageData)
{
messageData.SetMessageEncoder(null);
bufferedDataPool.Return(messageData);
}
class BinaryBufferedMessageData : BufferedMessageData
{
BinaryMessageEncoderFactory factory;
BinaryMessageEncoder messageEncoder;
Pool<XmlDictionaryReader> readerPool;
OnXmlDictionaryReaderClose onClose;
public BinaryBufferedMessageData(BinaryMessageEncoderFactory factory, int maxPoolSize)
: base(factory.RecycledStatePool)
{
this.factory = factory;
readerPool = new Pool<XmlDictionaryReader>(maxPoolSize);
onClose = new OnXmlDictionaryReaderClose(OnXmlReaderClosed);
}
public override MessageEncoder MessageEncoder
{
get { return messageEncoder; }
}
public override XmlDictionaryReaderQuotas Quotas
{
get { return factory.readerQuotas; }
}
public void SetMessageEncoder(BinaryMessageEncoder messageEncoder)
{
this.messageEncoder = messageEncoder;
}
protected override XmlDictionaryReader TakeXmlReader()
{
ArraySegment<byte> buffer = this.Buffer;
XmlDictionaryReader xmlReader = readerPool.Take();
if (xmlReader != null)
{
((IXmlBinaryReaderInitializer)xmlReader).SetInput(buffer.Array, buffer.Offset, buffer.Count,
factory.binaryVersion.Dictionary,
factory.bufferedReadReaderQuotas,
messageEncoder.ReaderSession,
onClose);
}
else
{
xmlReader = XmlDictionaryReader.CreateBinaryReader(buffer.Array, buffer.Offset, buffer.Count,
factory.binaryVersion.Dictionary,
factory.bufferedReadReaderQuotas,
messageEncoder.ReaderSession,
onClose);
if (TD.ReadPoolMissIsEnabled())
{
TD.ReadPoolMiss(xmlReader.GetType().Name);
}
}
return xmlReader;
}
protected override void ReturnXmlReader(XmlDictionaryReader reader)
{
readerPool.Return(reader);
}
protected override void OnClosed()
{
factory.ReturnBufferedData(this);
}
}
class BinaryBufferedMessageWriter : BufferedMessageWriter
{
XmlDictionaryWriter writer;
IXmlDictionary dictionary;
XmlBinaryWriterSession session;
public BinaryBufferedMessageWriter(IXmlDictionary dictionary)
{
this.dictionary = dictionary;
}
public BinaryBufferedMessageWriter(IXmlDictionary dictionary, XmlBinaryWriterSession session)
{
this.dictionary = dictionary;
this.session = session;
}
protected override XmlDictionaryWriter TakeXmlWriter(Stream stream)
{
XmlDictionaryWriter returnedWriter = writer;
if (returnedWriter == null)
{
returnedWriter = XmlDictionaryWriter.CreateBinaryWriter(stream, dictionary, session, false);
}
else
{
writer = null;
((IXmlBinaryWriterInitializer)returnedWriter).SetOutput(stream, dictionary, session, false);
}
return returnedWriter;
}
protected override void ReturnXmlWriter(XmlDictionaryWriter writer)
{
writer.Close();
if (this.writer == null)
{
this.writer = writer;
}
}
}
class BinaryMessageEncoder : MessageEncoder, ICompressedMessageEncoder, ITraceSourceStringProvider
{
const string SupportedCompressionTypesMessageProperty = "BinaryMessageEncoder.SupportedCompressionTypes";
BinaryMessageEncoderFactory factory;
bool isSession;
XmlBinaryWriterSessionWithQuota writerSession;
BinaryBufferedMessageWriter sessionMessageWriter;
XmlBinaryReaderSession readerSession;
XmlBinaryReaderSession readerSessionForLogging;
bool readerSessionForLoggingIsInvalid = false;
int writeIdCounter;
int idCounter;
int maxSessionSize;
int remainingReaderSessionSize;
bool isReaderSessionInvalid;
MessagePatterns messagePatterns;
string contentType;
string normalContentType;
string gzipCompressedContentType;
string deflateCompressedContentType;
CompressionFormat sessionCompressionFormat;
readonly long maxReceivedMessageSize;
public BinaryMessageEncoder(BinaryMessageEncoderFactory factory, bool isSession, int maxSessionSize)
{
this.factory = factory;
this.isSession = isSession;
this.maxSessionSize = maxSessionSize;
this.remainingReaderSessionSize = maxSessionSize;
this.normalContentType = isSession ? factory.binaryVersion.SessionContentType : factory.binaryVersion.ContentType;
this.gzipCompressedContentType = isSession ? BinaryVersion.GZipVersion1.SessionContentType : BinaryVersion.GZipVersion1.ContentType;
this.deflateCompressedContentType = isSession ? BinaryVersion.DeflateVersion1.SessionContentType : BinaryVersion.DeflateVersion1.ContentType;
this.sessionCompressionFormat = this.factory.CompressionFormat;
this.maxReceivedMessageSize = this.factory.MaxReceivedMessageSize;
switch (this.factory.CompressionFormat)
{
case CompressionFormat.Deflate:
this.contentType = this.deflateCompressedContentType;
break;
case CompressionFormat.GZip:
this.contentType = this.gzipCompressedContentType;
break;
default:
this.contentType = this.normalContentType;
break;
}
}
public override string ContentType
{
get
{
return this.contentType;
}
}
public override MessageVersion MessageVersion
{
get { return factory.messageVersion; }
}
public override string MediaType
{
get { return this.contentType; }
}
public XmlBinaryReaderSession ReaderSession
{
get { return readerSession; }
}
public bool CompressionEnabled
{
get { return this.factory.CompressionFormat != CompressionFormat.None; }
}
ArraySegment<byte> AddSessionInformationToMessage(ArraySegment<byte> messageData, BufferManager bufferManager, int maxMessageSize)
{
int dictionarySize = 0;
byte[] buffer = messageData.Array;
if (writerSession.HasNewStrings)
{
IList<XmlDictionaryString> newStrings = writerSession.GetNewStrings();
for (int i = 0; i < newStrings.Count; i++)
{
int utf8ValueSize = Encoding.UTF8.GetByteCount(newStrings[i].Value);
dictionarySize += IntEncoder.GetEncodedSize(utf8ValueSize) + utf8ValueSize;
}
int messageSize = messageData.Offset + messageData.Count;
int remainingMessageSize = maxMessageSize - messageSize;
if (remainingMessageSize - dictionarySize < 0)
{
string excMsg = SR.GetString(SR.MaxSentMessageSizeExceeded, maxMessageSize);
if (TD.MaxSentMessageSizeExceededIsEnabled())
{
TD.MaxSentMessageSizeExceeded(excMsg);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QuotaExceededException(excMsg));
}
int requiredBufferSize = messageData.Offset + messageData.Count + dictionarySize;
if (buffer.Length < requiredBufferSize)
{
byte[] newBuffer = bufferManager.TakeBuffer(requiredBufferSize);
Buffer.BlockCopy(buffer, messageData.Offset, newBuffer, messageData.Offset, messageData.Count);
bufferManager.ReturnBuffer(buffer);
buffer = newBuffer;
}
Buffer.BlockCopy(buffer, messageData.Offset, buffer, messageData.Offset + dictionarySize, messageData.Count);
int offset = messageData.Offset;
for (int i = 0; i < newStrings.Count; i++)
{
string newString = newStrings[i].Value;
int utf8ValueSize = Encoding.UTF8.GetByteCount(newString);
offset += IntEncoder.Encode(utf8ValueSize, buffer, offset);
offset += Encoding.UTF8.GetBytes(newString, 0, newString.Length, buffer, offset);
}
writerSession.ClearNewStrings();
}
int headerSize = IntEncoder.GetEncodedSize(dictionarySize);
int newOffset = messageData.Offset - headerSize;
int newSize = headerSize + messageData.Count + dictionarySize;
IntEncoder.Encode(dictionarySize, buffer, newOffset);
return new ArraySegment<byte>(buffer, newOffset, newSize);
}
ArraySegment<byte> ExtractSessionInformationFromMessage(ArraySegment<byte> messageData)
{
if (isReaderSessionInvalid)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataException(SR.GetString(SR.BinaryEncoderSessionInvalid)));
}
byte[] buffer = messageData.Array;
int dictionarySize;
int headerSize;
int newOffset;
int newSize;
bool throwing = true;
try
{
IntDecoder decoder = new IntDecoder();
headerSize = decoder.Decode(buffer, messageData.Offset, messageData.Count);
dictionarySize = decoder.Value;
if (dictionarySize > messageData.Count)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataException(SR.GetString(SR.BinaryEncoderSessionMalformed)));
}
newOffset = messageData.Offset + headerSize + dictionarySize;
newSize = messageData.Count - headerSize - dictionarySize;
if (newSize < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataException(SR.GetString(SR.BinaryEncoderSessionMalformed)));
}
if (dictionarySize > 0)
{
if (dictionarySize > remainingReaderSessionSize)
{
string message = SR.GetString(SR.BinaryEncoderSessionTooLarge, this.maxSessionSize);
if (TD.MaxSessionSizeReachedIsEnabled())
{
TD.MaxSessionSizeReached(message);
}
Exception inner = new QuotaExceededException(message);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(message, inner));
}
else
{
remainingReaderSessionSize -= dictionarySize;
}
int size = dictionarySize;
int offset = messageData.Offset + headerSize;
while (size > 0)
{
decoder.Reset();
int bytesDecoded = decoder.Decode(buffer, offset, size);
int utf8ValueSize = decoder.Value;
offset += bytesDecoded;
size -= bytesDecoded;
if (utf8ValueSize > size)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataException(SR.GetString(SR.BinaryEncoderSessionMalformed)));
}
string value = Encoding.UTF8.GetString(buffer, offset, utf8ValueSize);
offset += utf8ValueSize;
size -= utf8ValueSize;
readerSession.Add(idCounter, value);
idCounter++;
}
}
throwing = false;
}
finally
{
if (throwing)
{
isReaderSessionInvalid = true;
}
}
return new ArraySegment<byte>(buffer, newOffset, newSize);
}
public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
{
if (bufferManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("bufferManager");
}
CompressionFormat compressionFormat = this.CheckContentType(contentType);
if (TD.BinaryMessageDecodingStartIsEnabled())
{
TD.BinaryMessageDecodingStart();
}
if (compressionFormat != CompressionFormat.None)
{
MessageEncoderCompressionHandler.DecompressBuffer(ref buffer, bufferManager, compressionFormat, this.maxReceivedMessageSize);
}
if (isSession)
{
if (readerSession == null)
{
readerSession = new XmlBinaryReaderSession();
messagePatterns = new MessagePatterns(factory.binaryVersion.Dictionary, readerSession, this.MessageVersion);
}
try
{
buffer = ExtractSessionInformationFromMessage(buffer);
}
catch (InvalidDataException)
{
MessageLogger.LogMessage(buffer, MessageLoggingSource.Malformed);
throw;
}
}
BinaryBufferedMessageData messageData = factory.TakeBufferedData(this);
Message message;
if (messagePatterns != null)
{
message = messagePatterns.TryCreateMessage(buffer.Array, buffer.Offset, buffer.Count, bufferManager, messageData);
}
else
{
message = null;
}
if (message == null)
{
messageData.Open(buffer, bufferManager);
RecycledMessageState messageState = messageData.TakeMessageState();
if (messageState == null)
{
messageState = new RecycledMessageState();
}
message = new BufferedMessage(messageData, messageState);
}
message.Properties.Encoder = this;
if (TD.MessageReadByEncoderIsEnabled() && buffer != null)
{
TD.MessageReadByEncoder(
EventTraceActivityHelper.TryExtractActivity(message, true),
buffer.Count,
this);
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
}
return message;
}
public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType)
{
if (stream == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("stream");
}
CompressionFormat compressionFormat = this.CheckContentType(contentType);
if (TD.BinaryMessageDecodingStartIsEnabled())
{
TD.BinaryMessageDecodingStart();
}
if (compressionFormat != CompressionFormat.None)
{
stream = new MaxMessageSizeStream(
MessageEncoderCompressionHandler.GetDecompressStream(stream, compressionFormat), this.maxReceivedMessageSize);
}
XmlDictionaryReader reader = factory.TakeStreamedReader(stream);
Message message = Message.CreateMessage(reader, maxSizeOfHeaders, factory.messageVersion);
message.Properties.Encoder = this;
if (TD.StreamedMessageReadByEncoderIsEnabled())
{
TD.StreamedMessageReadByEncoder(
EventTraceActivityHelper.TryExtractActivity(message, true));
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
}
return message;
}
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
if (bufferManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("bufferManager");
}
if (maxMessageSize < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxMessageSize", maxMessageSize,
SR.GetString(SR.ValueMustBeNonNegative)));
}
EventTraceActivity eventTraceActivity = null;
if (TD.BinaryMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
TD.BinaryMessageEncodingStart(eventTraceActivity);
}
message.Properties.Encoder = this;
if (isSession)
{
if (writerSession == null)
{
writerSession = new XmlBinaryWriterSessionWithQuota(maxSessionSize);
sessionMessageWriter = new BinaryBufferedMessageWriter(factory.binaryVersion.Dictionary, writerSession);
}
messageOffset += IntEncoder.MaxEncodedSize;
}
if (messageOffset < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("messageOffset", messageOffset,
SR.GetString(SR.ValueMustBeNonNegative)));
}
if (messageOffset > maxMessageSize)
{
string excMsg = SR.GetString(SR.MaxSentMessageSizeExceeded, maxMessageSize);
if (TD.MaxSentMessageSizeExceededIsEnabled())
{
TD.MaxSentMessageSizeExceeded(excMsg);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QuotaExceededException(excMsg));
}
ThrowIfMismatchedMessageVersion(message);
BinaryBufferedMessageWriter messageWriter;
if (isSession)
{
messageWriter = sessionMessageWriter;
}
else
{
messageWriter = factory.TakeBufferedWriter();
}
ArraySegment<byte> messageData = messageWriter.WriteMessage(message, bufferManager, messageOffset, maxMessageSize);
if (MessageLogger.LogMessagesAtTransportLevel && !this.readerSessionForLoggingIsInvalid)
{
if (isSession)
{
if (this.readerSessionForLogging == null)
{
this.readerSessionForLogging = new XmlBinaryReaderSession();
}
if (this.writerSession.HasNewStrings)
{
foreach (XmlDictionaryString xmlDictionaryString in this.writerSession.GetNewStrings())
{
this.readerSessionForLogging.Add(this.writeIdCounter++, xmlDictionaryString.Value);
}
}
}
XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateBinaryReader(messageData.Array, messageData.Offset, messageData.Count, XD.Dictionary, XmlDictionaryReaderQuotas.Max, this.readerSessionForLogging, null);
MessageLogger.LogMessage(ref message, xmlDictionaryReader, MessageLoggingSource.TransportSend);
}
else
{
this.readerSessionForLoggingIsInvalid = true;
}
if (isSession)
{
messageData = AddSessionInformationToMessage(messageData, bufferManager, maxMessageSize);
}
else
{
factory.ReturnMessageWriter(messageWriter);
}
if (TD.MessageWrittenByEncoderIsEnabled() && messageData != null)
{
TD.MessageWrittenByEncoder(
eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message),
messageData.Count,
this);
}
CompressionFormat compressionFormat = this.CheckCompressedWrite(message);
if (compressionFormat != CompressionFormat.None)
{
MessageEncoderCompressionHandler.CompressBuffer(ref messageData, bufferManager, compressionFormat);
}
return messageData;
}
public override void WriteMessage(Message message, Stream stream)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message"));
}
if (stream == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
}
EventTraceActivity eventTraceActivity = null;
if (TD.BinaryMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
TD.BinaryMessageEncodingStart(eventTraceActivity);
}
CompressionFormat compressionFormat = this.CheckCompressedWrite(message);
if (compressionFormat != CompressionFormat.None)
{
stream = MessageEncoderCompressionHandler.GetCompressStream(stream, compressionFormat);
}
ThrowIfMismatchedMessageVersion(message);
message.Properties.Encoder = this;
XmlDictionaryWriter xmlWriter = factory.TakeStreamedWriter(stream);
message.WriteMessage(xmlWriter);
xmlWriter.Flush();
if (TD.StreamedMessageWrittenByEncoderIsEnabled())
{
TD.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message));
}
factory.ReturnStreamedWriter(xmlWriter);
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
}
if (compressionFormat != CompressionFormat.None)
{
stream.Close();
}
}
public override bool IsContentTypeSupported(string contentType)
{
bool supported = true;
if (!base.IsContentTypeSupported(contentType))
{
if (this.CompressionEnabled)
{
supported = (this.factory.CompressionFormat == CompressionFormat.GZip &&
base.IsContentTypeSupported(contentType, this.gzipCompressedContentType, this.gzipCompressedContentType)) ||
(this.factory.CompressionFormat == CompressionFormat.Deflate &&
base.IsContentTypeSupported(contentType, this.deflateCompressedContentType, this.deflateCompressedContentType)) ||
base.IsContentTypeSupported(contentType, this.normalContentType, this.normalContentType);
}
else
{
supported = false;
}
}
return supported;
}
public void SetSessionContentType(string contentType)
{
if (base.IsContentTypeSupported(contentType, this.gzipCompressedContentType, this.gzipCompressedContentType))
{
this.sessionCompressionFormat = CompressionFormat.GZip;
}
else if (base.IsContentTypeSupported(contentType, this.deflateCompressedContentType, this.deflateCompressedContentType))
{
this.sessionCompressionFormat = CompressionFormat.Deflate;
}
else
{
this.sessionCompressionFormat = CompressionFormat.None;
}
}
public void AddCompressedMessageProperties(Message message, string supportedCompressionTypes)
{
message.Properties.Add(SupportedCompressionTypesMessageProperty, supportedCompressionTypes);
}
static bool ContentTypeEqualsOrStartsWith(string contentType, string supportedContentType)
{
return contentType == supportedContentType || contentType.StartsWith(supportedContentType, StringComparison.OrdinalIgnoreCase);
}
CompressionFormat CheckContentType(string contentType)
{
CompressionFormat compressionFormat = CompressionFormat.None;
if (contentType == null)
{
compressionFormat = this.sessionCompressionFormat;
}
else
{
if (!this.CompressionEnabled)
{
if (!ContentTypeEqualsOrStartsWith(contentType, this.ContentType))
{
throw FxTrace.Exception.AsError(new ProtocolException(SR.GetString(SR.EncoderUnrecognizedContentType, contentType, this.ContentType)));
}
}
else
{
if (this.factory.CompressionFormat == CompressionFormat.GZip && ContentTypeEqualsOrStartsWith(contentType, this.gzipCompressedContentType))
{
compressionFormat = CompressionFormat.GZip;
}
else if (this.factory.CompressionFormat == CompressionFormat.Deflate && ContentTypeEqualsOrStartsWith(contentType, this.deflateCompressedContentType))
{
compressionFormat = CompressionFormat.Deflate;
}
else if (ContentTypeEqualsOrStartsWith(contentType, this.normalContentType))
{
compressionFormat = CompressionFormat.None;
}
else
{
throw FxTrace.Exception.AsError(new ProtocolException(SR.GetString(SR.EncoderUnrecognizedContentType, contentType, this.ContentType)));
}
}
}
return compressionFormat;
}
CompressionFormat CheckCompressedWrite(Message message)
{
CompressionFormat compressionFormat = this.sessionCompressionFormat;
if (compressionFormat != CompressionFormat.None && !this.isSession)
{
string acceptEncoding;
if (message.Properties.TryGetValue<string>(SupportedCompressionTypesMessageProperty, out acceptEncoding) &&
acceptEncoding != null)
{
acceptEncoding = acceptEncoding.ToLowerInvariant();
if ((compressionFormat == CompressionFormat.GZip &&
!acceptEncoding.Contains(MessageEncoderCompressionHandler.GZipContentEncoding)) ||
(compressionFormat == CompressionFormat.Deflate &&
!acceptEncoding.Contains(MessageEncoderCompressionHandler.DeflateContentEncoding)))
{
compressionFormat = CompressionFormat.None;
}
}
}
return compressionFormat;
}
string ITraceSourceStringProvider.GetSourceString()
{
return base.GetTraceSourceString();
}
}
class XmlBinaryWriterSessionWithQuota : XmlBinaryWriterSession
{
int bytesRemaining;
List<XmlDictionaryString> newStrings;
public XmlBinaryWriterSessionWithQuota(int maxSessionSize)
{
bytesRemaining = maxSessionSize;
}
public bool HasNewStrings
{
get { return newStrings != null; }
}
public override bool TryAdd(XmlDictionaryString s, out int key)
{
if (bytesRemaining == 0)
{
key = -1;
return false;
}
int bytesRequired = Encoding.UTF8.GetByteCount(s.Value);
bytesRequired += IntEncoder.GetEncodedSize(bytesRequired);
if (bytesRequired > bytesRemaining)
{
key = -1;
bytesRemaining = 0;
return false;
}
if (base.TryAdd(s, out key))
{
if (newStrings == null)
{
newStrings = new List<XmlDictionaryString>();
}
newStrings.Add(s);
bytesRemaining -= bytesRequired;
return true;
}
else
{
return false;
}
}
public IList<XmlDictionaryString> GetNewStrings()
{
return newStrings;
}
public void ClearNewStrings()
{
newStrings = null;
}
}
}
class BinaryFormatBuilder
{
List<byte> bytes;
public BinaryFormatBuilder()
{
this.bytes = new List<byte>();
}
public int Count
{
get { return bytes.Count; }
}
public void AppendPrefixDictionaryElement(char prefix, int key)
{
this.AppendNode(XmlBinaryNodeType.PrefixDictionaryElementA + GetPrefixOffset(prefix));
this.AppendKey(key);
}
public void AppendDictionaryXmlnsAttribute(char prefix, int key)
{
this.AppendNode(XmlBinaryNodeType.DictionaryXmlnsAttribute);
this.AppendUtf8(prefix);
this.AppendKey(key);
}
public void AppendPrefixDictionaryAttribute(char prefix, int key, char value)
{
this.AppendNode(XmlBinaryNodeType.PrefixDictionaryAttributeA + GetPrefixOffset(prefix));
this.AppendKey(key);
if (value == '1')
{
this.AppendNode(XmlBinaryNodeType.OneText);
}
else
{
this.AppendNode(XmlBinaryNodeType.Chars8Text);
this.AppendUtf8(value);
}
}
public void AppendDictionaryAttribute(char prefix, int key, char value)
{
this.AppendNode(XmlBinaryNodeType.DictionaryAttribute);
this.AppendUtf8(prefix);
this.AppendKey(key);
this.AppendNode(XmlBinaryNodeType.Chars8Text);
this.AppendUtf8(value);
}
public void AppendDictionaryTextWithEndElement(int key)
{
this.AppendNode(XmlBinaryNodeType.DictionaryTextWithEndElement);
this.AppendKey(key);
}
public void AppendDictionaryTextWithEndElement()
{
this.AppendNode(XmlBinaryNodeType.DictionaryTextWithEndElement);
}
public void AppendUniqueIDWithEndElement()
{
this.AppendNode(XmlBinaryNodeType.UniqueIdTextWithEndElement);
}
public void AppendEndElement()
{
this.AppendNode(XmlBinaryNodeType.EndElement);
}
void AppendKey(int key)
{
if (key < 0 || key >= 0x4000)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("key", key,
SR.GetString(SR.ValueMustBeInRange, 0, 0x4000)));
}
if (key >= 0x80)
{
this.AppendByte((key & 0x7f) | 0x80);
this.AppendByte(key >> 7);
}
else
{
this.AppendByte(key);
}
}
void AppendNode(XmlBinaryNodeType value)
{
this.AppendByte((int)value);
}
void AppendByte(int value)
{
if (value < 0 || value > 0xFF)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.ValueMustBeInRange, 0, 0xFF)));
}
this.bytes.Add((byte)value);
}
void AppendUtf8(char value)
{
AppendByte(1);
AppendByte((int)value);
}
public int GetStaticKey(int value)
{
return value * 2;
}
public int GetSessionKey(int value)
{
return value * 2 + 1;
}
int GetPrefixOffset(char prefix)
{
if (prefix < 'a' && prefix > 'z')
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("prefix", prefix,
SR.GetString(SR.ValueMustBeInRange, 'a', 'z')));
}
return prefix - 'a';
}
public byte[] ToByteArray()
{
byte[] array = this.bytes.ToArray();
this.bytes.Clear();
return array;
}
}
static class BinaryFormatParser
{
public static bool IsSessionKey(int value)
{
return (value & 1) != 0;
}
public static int GetSessionKey(int value)
{
return value / 2;
}
public static int GetStaticKey(int value)
{
return value / 2;
}
public static int ParseInt32(byte[] buffer, int offset, int size)
{
switch (size)
{
case 1:
return buffer[offset];
case 2:
return (buffer[offset] & 0x7f) + (buffer[offset + 1] << 7);
case 3:
return (buffer[offset] & 0x7f) + ((buffer[offset + 1] & 0x7f) << 7) + (buffer[offset + 2] << 14);
case 4:
return (buffer[offset] & 0x7f) + ((buffer[offset + 1] & 0x7f) << 7) + ((buffer[offset + 2] & 0x7f) << 14) + (buffer[offset + 3] << 21);
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("size", size,
SR.GetString(SR.ValueMustBeInRange, 1, 4)));
}
}
public static int ParseKey(byte[] buffer, int offset, int size)
{
return ParseInt32(buffer, offset, size);
}
public unsafe static UniqueId ParseUniqueID(byte[] buffer, int offset, int size)
{
return new UniqueId(buffer, offset);
}
public static int MatchBytes(byte[] buffer, int offset, int size, byte[] buffer2)
{
if (size < buffer2.Length)
{
return 0;
}
int j = offset;
for (int i = 0; i < buffer2.Length; i++, j++)
{
if (buffer2[i] != buffer[j])
{
return 0;
}
}
return buffer2.Length;
}
public static bool MatchAttributeNode(byte[] buffer, int offset, int size)
{
const XmlBinaryNodeType minAttribute = XmlBinaryNodeType.ShortAttribute;
const XmlBinaryNodeType maxAttribute = XmlBinaryNodeType.DictionaryAttribute;
if (size < 1)
{
return false;
}
XmlBinaryNodeType nodeType = (XmlBinaryNodeType)buffer[offset];
return nodeType >= minAttribute && nodeType <= maxAttribute;
}
public static int MatchKey(byte[] buffer, int offset, int size)
{
return MatchInt32(buffer, offset, size);
}
public static int MatchInt32(byte[] buffer, int offset, int size)
{
if (size > 0)
{
if ((buffer[offset] & 0x80) == 0)
{
return 1;
}
}
if (size > 1)
{
if ((buffer[offset + 1] & 0x80) == 0)
{
return 2;
}
}
if (size > 2)
{
if ((buffer[offset + 2] & 0x80) == 0)
{
return 3;
}
}
if (size > 3)
{
if ((buffer[offset + 3] & 0x80) == 0)
{
return 4;
}
}
return 0;
}
public static int MatchUniqueID(byte[] buffer, int offset, int size)
{
if (size < 16)
{
return 0;
}
return 16;
}
}
class MessagePatterns
{
static readonly byte[] commonFragment; // <Envelope><Headers><Action>
static readonly byte[] requestFragment1; // </Action><MessageID>
static readonly byte[] requestFragment2; // </MessageID><ReplyTo>...</ReplyTo><To>session-to-key</To></Headers><Body>
static readonly byte[] responseFragment1; // </Action><RelatesTo>
static readonly byte[] responseFragment2; // </RelatesTo><To>static-anonymous-key</To></Headers><Body>
static readonly byte[] bodyFragment; // <Envelope><Body>
const int ToValueSessionKey = 1;
IXmlDictionary dictionary;
XmlBinaryReaderSession readerSession;
ToHeader toHeader;
MessageVersion messageVersion;
static MessagePatterns()
{
BinaryFormatBuilder builder = new BinaryFormatBuilder();
MessageDictionary messageDictionary = XD.MessageDictionary;
Message12Dictionary message12Dictionary = XD.Message12Dictionary;
AddressingDictionary addressingDictionary = XD.AddressingDictionary;
Addressing10Dictionary addressing10Dictionary = XD.Addressing10Dictionary;
char messagePrefix = MessageStrings.Prefix[0];
char addressingPrefix = AddressingStrings.Prefix[0];
// <s:Envelope xmlns:s="soap-ns" xmlns="addressing-ns">
builder.AppendPrefixDictionaryElement(messagePrefix, builder.GetStaticKey(messageDictionary.Envelope.Key));
builder.AppendDictionaryXmlnsAttribute(messagePrefix, builder.GetStaticKey(message12Dictionary.Namespace.Key));
builder.AppendDictionaryXmlnsAttribute(addressingPrefix, builder.GetStaticKey(addressing10Dictionary.Namespace.Key));
// <s:Header>
builder.AppendPrefixDictionaryElement(messagePrefix, builder.GetStaticKey(messageDictionary.Header.Key));
// <a:Action>...
builder.AppendPrefixDictionaryElement(addressingPrefix, builder.GetStaticKey(addressingDictionary.Action.Key));
builder.AppendPrefixDictionaryAttribute(messagePrefix, builder.GetStaticKey(messageDictionary.MustUnderstand.Key), '1');
builder.AppendDictionaryTextWithEndElement();
commonFragment = builder.ToByteArray();
// <a:MessageID>...
builder.AppendPrefixDictionaryElement(addressingPrefix, builder.GetStaticKey(addressingDictionary.MessageId.Key));
builder.AppendUniqueIDWithEndElement();
requestFragment1 = builder.ToByteArray();
// <a:ReplyTo><a:Address>static-anonymous-key</a:Address></a:ReplyTo>
builder.AppendPrefixDictionaryElement(addressingPrefix, builder.GetStaticKey(addressingDictionary.ReplyTo.Key));
builder.AppendPrefixDictionaryElement(addressingPrefix, builder.GetStaticKey(addressingDictionary.Address.Key));
builder.AppendDictionaryTextWithEndElement(builder.GetStaticKey(addressing10Dictionary.Anonymous.Key));
builder.AppendEndElement();
// <a:To>session-to-key</a:To>
builder.AppendPrefixDictionaryElement(addressingPrefix, builder.GetStaticKey(addressingDictionary.To.Key));
builder.AppendPrefixDictionaryAttribute(messagePrefix, builder.GetStaticKey(messageDictionary.MustUnderstand.Key), '1');
builder.AppendDictionaryTextWithEndElement(builder.GetSessionKey(ToValueSessionKey));
// </s:Header>
builder.AppendEndElement();
// <s:Body>
builder.AppendPrefixDictionaryElement(messagePrefix, builder.GetStaticKey(messageDictionary.Body.Key));
requestFragment2 = builder.ToByteArray();
// <a:RelatesTo>...
builder.AppendPrefixDictionaryElement(addressingPrefix, builder.GetStaticKey(addressingDictionary.RelatesTo.Key));
builder.AppendUniqueIDWithEndElement();
responseFragment1 = builder.ToByteArray();
// <a:To>static-anonymous-key</a:To>
builder.AppendPrefixDictionaryElement(addressingPrefix, builder.GetStaticKey(addressingDictionary.To.Key));
builder.AppendPrefixDictionaryAttribute(messagePrefix, builder.GetStaticKey(messageDictionary.MustUnderstand.Key), '1');
builder.AppendDictionaryTextWithEndElement(builder.GetStaticKey(addressing10Dictionary.Anonymous.Key));
// </s:Header>
builder.AppendEndElement();
// <s:Body>
builder.AppendPrefixDictionaryElement(messagePrefix, builder.GetStaticKey(messageDictionary.Body.Key));
responseFragment2 = builder.ToByteArray();
// <s:Envelope xmlns:s="soap-ns" xmlns="addressing-ns">
builder.AppendPrefixDictionaryElement(messagePrefix, builder.GetStaticKey(messageDictionary.Envelope.Key));
builder.AppendDictionaryXmlnsAttribute(messagePrefix, builder.GetStaticKey(message12Dictionary.Namespace.Key));
builder.AppendDictionaryXmlnsAttribute(addressingPrefix, builder.GetStaticKey(addressing10Dictionary.Namespace.Key));
// <s:Body>
builder.AppendPrefixDictionaryElement(messagePrefix, builder.GetStaticKey(messageDictionary.Body.Key));
bodyFragment = builder.ToByteArray();
}
public MessagePatterns(IXmlDictionary dictionary, XmlBinaryReaderSession readerSession, MessageVersion messageVersion)
{
this.dictionary = dictionary;
this.readerSession = readerSession;
this.messageVersion = messageVersion;
}
public Message TryCreateMessage(byte[] buffer, int offset, int size, BufferManager bufferManager, BufferedMessageData messageData)
{
RelatesToHeader relatesToHeader;
MessageIDHeader messageIDHeader;
XmlDictionaryString toString;
int currentOffset = offset;
int remainingSize = size;
int bytesMatched = BinaryFormatParser.MatchBytes(buffer, currentOffset, remainingSize, commonFragment);
if (bytesMatched == 0)
{
return null;
}
currentOffset += bytesMatched;
remainingSize -= bytesMatched;
bytesMatched = BinaryFormatParser.MatchKey(buffer, currentOffset, remainingSize);
if (bytesMatched == 0)
{
return null;
}
int actionOffset = currentOffset;
int actionSize = bytesMatched;
currentOffset += bytesMatched;
remainingSize -= bytesMatched;
int totalBytesMatched;
bytesMatched = BinaryFormatParser.MatchBytes(buffer, currentOffset, remainingSize, requestFragment1);
if (bytesMatched != 0)
{
currentOffset += bytesMatched;
remainingSize -= bytesMatched;
bytesMatched = BinaryFormatParser.MatchUniqueID(buffer, currentOffset, remainingSize);
if (bytesMatched == 0)
{
return null;
}
int messageIDOffset = currentOffset;
int messageIDSize = bytesMatched;
currentOffset += bytesMatched;
remainingSize -= bytesMatched;
bytesMatched = BinaryFormatParser.MatchBytes(buffer, currentOffset, remainingSize, requestFragment2);
if (bytesMatched == 0)
{
return null;
}
currentOffset += bytesMatched;
remainingSize -= bytesMatched;
if (BinaryFormatParser.MatchAttributeNode(buffer, currentOffset, remainingSize))
{
return null;
}
UniqueId messageId = BinaryFormatParser.ParseUniqueID(buffer, messageIDOffset, messageIDSize);
messageIDHeader = MessageIDHeader.Create(messageId, messageVersion.Addressing);
relatesToHeader = null;
if (!readerSession.TryLookup(ToValueSessionKey, out toString))
{
return null;
}
totalBytesMatched = requestFragment1.Length + messageIDSize + requestFragment2.Length;
}
else
{
bytesMatched = BinaryFormatParser.MatchBytes(buffer, currentOffset, remainingSize, responseFragment1);
if (bytesMatched == 0)
{
return null;
}
currentOffset += bytesMatched;
remainingSize -= bytesMatched;
bytesMatched = BinaryFormatParser.MatchUniqueID(buffer, currentOffset, remainingSize);
if (bytesMatched == 0)
{
return null;
}
int messageIDOffset = currentOffset;
int messageIDSize = bytesMatched;
currentOffset += bytesMatched;
remainingSize -= bytesMatched;
bytesMatched = BinaryFormatParser.MatchBytes(buffer, currentOffset, remainingSize, responseFragment2);
if (bytesMatched == 0)
{
return null;
}
currentOffset += bytesMatched;
remainingSize -= bytesMatched;
if (BinaryFormatParser.MatchAttributeNode(buffer, currentOffset, remainingSize))
{
return null;
}
UniqueId messageId = BinaryFormatParser.ParseUniqueID(buffer, messageIDOffset, messageIDSize);
relatesToHeader = RelatesToHeader.Create(messageId, messageVersion.Addressing);
messageIDHeader = null;
toString = XD.Addressing10Dictionary.Anonymous;
totalBytesMatched = responseFragment1.Length + messageIDSize + responseFragment2.Length;
}
totalBytesMatched += commonFragment.Length + actionSize;
int actionKey = BinaryFormatParser.ParseKey(buffer, actionOffset, actionSize);
XmlDictionaryString actionString;
if (!TryLookupKey(actionKey, out actionString))
{
return null;
}
ActionHeader actionHeader = ActionHeader.Create(actionString, messageVersion.Addressing);
if (toHeader == null)
{
toHeader = ToHeader.Create(new Uri(toString.Value), messageVersion.Addressing);
}
int abandonedSize = totalBytesMatched - bodyFragment.Length;
offset += abandonedSize;
size -= abandonedSize;
Buffer.BlockCopy(bodyFragment, 0, buffer, offset, bodyFragment.Length);
messageData.Open(new ArraySegment<byte>(buffer, offset, size), bufferManager);
PatternMessage patternMessage = new PatternMessage(messageData, this.messageVersion);
MessageHeaders headers = patternMessage.Headers;
headers.AddActionHeader(actionHeader);
if (messageIDHeader != null)
{
headers.AddMessageIDHeader(messageIDHeader);
headers.AddReplyToHeader(ReplyToHeader.AnonymousReplyTo10);
}
else
{
headers.AddRelatesToHeader(relatesToHeader);
}
headers.AddToHeader(toHeader);
return patternMessage;
}
bool TryLookupKey(int key, out XmlDictionaryString result)
{
if (BinaryFormatParser.IsSessionKey(key))
{
return readerSession.TryLookup(BinaryFormatParser.GetSessionKey(key), out result);
}
else
{
return dictionary.TryLookup(BinaryFormatParser.GetStaticKey(key), out result);
}
}
sealed class PatternMessage : ReceivedMessage
{
IBufferedMessageData messageData;
MessageHeaders headers;
RecycledMessageState recycledMessageState;
MessageProperties properties;
XmlDictionaryReader reader;
public PatternMessage(IBufferedMessageData messageData, MessageVersion messageVersion)
{
this.messageData = messageData;
recycledMessageState = messageData.TakeMessageState();
if (recycledMessageState == null)
{
recycledMessageState = new RecycledMessageState();
}
properties = recycledMessageState.TakeProperties();
if (properties == null)
{
this.properties = new MessageProperties();
}
headers = recycledMessageState.TakeHeaders();
if (headers == null)
{
headers = new MessageHeaders(messageVersion);
}
else
{
headers.Init(messageVersion);
}
XmlDictionaryReader reader = messageData.GetMessageReader();
reader.ReadStartElement();
VerifyStartBody(reader, messageVersion.Envelope);
ReadStartBody(reader);
this.reader = reader;
}
public PatternMessage(IBufferedMessageData messageData, MessageVersion messageVersion,
KeyValuePair<string, object>[] properties, MessageHeaders headers)
{
this.messageData = messageData;
this.messageData.Open();
this.recycledMessageState = this.messageData.TakeMessageState();
if (this.recycledMessageState == null)
{
this.recycledMessageState = new RecycledMessageState();
}
this.properties = recycledMessageState.TakeProperties();
if (this.properties == null)
{
this.properties = new MessageProperties();
}
if (properties != null)
{
this.properties.CopyProperties(properties);
}
this.headers = recycledMessageState.TakeHeaders();
if (this.headers == null)
{
this.headers = new MessageHeaders(messageVersion);
}
if (headers != null)
{
this.headers.CopyHeadersFrom(headers);
}
XmlDictionaryReader reader = messageData.GetMessageReader();
reader.ReadStartElement();
VerifyStartBody(reader, messageVersion.Envelope);
ReadStartBody(reader);
this.reader = reader;
}
public override MessageHeaders Headers
{
get
{
if (IsDisposed)
#pragma warning suppress 56503 // [....], Invalid State after dispose
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateMessageDisposedException());
}
return headers;
}
}
public override MessageProperties Properties
{
get
{
if (IsDisposed)
#pragma warning suppress 56503 // [....], Invalid State after dispose
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateMessageDisposedException());
}
return properties;
}
}
public override MessageVersion Version
{
get
{
if (IsDisposed)
{
#pragma warning suppress 56503 // [....], Invalid State after dispose
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateMessageDisposedException());
}
return headers.MessageVersion;
}
}
internal override RecycledMessageState RecycledMessageState
{
get { return recycledMessageState; }
}
XmlDictionaryReader GetBufferedReaderAtBody()
{
XmlDictionaryReader reader = messageData.GetMessageReader();
reader.ReadStartElement();
reader.ReadStartElement();
return reader;
}
protected override void OnBodyToString(XmlDictionaryWriter writer)
{
using (XmlDictionaryReader reader = GetBufferedReaderAtBody())
{
while (reader.NodeType != XmlNodeType.EndElement)
{
writer.WriteNode(reader, false);
}
}
}
protected override void OnClose()
{
Exception ex = null;
try
{
base.OnClose();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
ex = e;
}
try
{
properties.Dispose();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ex == null)
{
ex = e;
}
}
try
{
if (reader != null)
{
reader.Close();
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ex == null)
{
ex = e;
}
}
try
{
recycledMessageState.ReturnHeaders(headers);
recycledMessageState.ReturnProperties(properties);
messageData.ReturnMessageState(recycledMessageState);
recycledMessageState = null;
messageData.Close();
messageData = null;
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (ex == null)
{
ex = e;
}
}
if (ex != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ex);
}
}
protected override MessageBuffer OnCreateBufferedCopy(int maxBufferSize)
{
KeyValuePair<string, object>[] properties = new KeyValuePair<string, object>[Properties.Count];
((ICollection<KeyValuePair<string, object>>)Properties).CopyTo(properties, 0);
messageData.EnableMultipleUsers();
return new PatternMessageBuffer(this.messageData, this.Version, properties, this.headers);
}
protected override XmlDictionaryReader OnGetReaderAtBodyContents()
{
XmlDictionaryReader reader = this.reader;
this.reader = null;
return reader;
}
protected override string OnGetBodyAttribute(string localName, string ns)
{
return null;
}
}
class PatternMessageBuffer : MessageBuffer
{
bool closed;
MessageHeaders headers;
IBufferedMessageData messageDataAtBody;
MessageVersion messageVersion;
KeyValuePair<string, object>[] properties;
object thisLock = new object();
RecycledMessageState recycledMessageState;
public PatternMessageBuffer(IBufferedMessageData messageDataAtBody, MessageVersion messageVersion,
KeyValuePair<string, object>[] properties, MessageHeaders headers)
{
this.messageDataAtBody = messageDataAtBody;
this.messageDataAtBody.Open();
this.recycledMessageState = this.messageDataAtBody.TakeMessageState();
if (this.recycledMessageState == null)
{
this.recycledMessageState = new RecycledMessageState();
}
this.headers = this.recycledMessageState.TakeHeaders();
if (this.headers == null)
{
this.headers = new MessageHeaders(messageVersion);
}
this.headers.CopyHeadersFrom(headers);
this.properties = properties;
this.messageVersion = messageVersion;
}
public override int BufferSize
{
get
{
lock (this.ThisLock)
{
if (this.closed)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
}
return messageDataAtBody.Buffer.Count;
}
}
}
object ThisLock
{
get
{
return this.thisLock;
}
}
public override void Close()
{
lock (this.thisLock)
{
if (!this.closed)
{
this.closed = true;
this.recycledMessageState.ReturnHeaders(this.headers);
this.messageDataAtBody.ReturnMessageState(this.recycledMessageState);
this.messageDataAtBody.Close();
this.recycledMessageState = null;
this.messageDataAtBody = null;
this.properties = null;
this.messageVersion = null;
this.headers = null;
}
}
}
public override Message CreateMessage()
{
lock (this.ThisLock)
{
if (this.closed)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
}
return new PatternMessage(this.messageDataAtBody, this.messageVersion, this.properties,
this.headers);
}
}
}
}
}