private BinaryBufferedMessageData TakeBufferedData(BinaryMessageEncoder messageEncoder)
{
if (this.bufferedDataPool == null)
{
lock (this.ThisLock)
{
if (this.bufferedDataPool == null)
{
this.bufferedDataPool = new SynchronizedPool<BinaryBufferedMessageData>(this.maxReadPoolSize);
}
}
}
BinaryBufferedMessageData data = this.bufferedDataPool.Take();
if (data == null)
{
data = new BinaryBufferedMessageData(this, 2);
}
data.SetMessageEncoder(messageEncoder);
return data;
}
private MtomBufferedMessageWriter TakeBufferedWriter()
{
if (this.bufferedWriterPool == null)
{
lock (this.thisLock)
{
if (this.bufferedWriterPool == null)
{
this.bufferedWriterPool = new SynchronizedPool<MtomBufferedMessageWriter>(this.maxWritePoolSize);
}
}
}
MtomBufferedMessageWriter writer = this.bufferedWriterPool.Take();
if (writer == null)
{
writer = new MtomBufferedMessageWriter(this);
}
return writer;
}
internal SynchronizedBufferPool(int bufferSize, int limit)
: base(bufferSize, limit)
{
_innerPool = new SynchronizedPool<byte[]>(limit);
}
private 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 (WcfEventSource.Instance.ReadPoolMissIsEnabled())
{
WcfEventSource.Instance.ReadPoolMiss(messageData.GetType().Name);
}
}
messageData.SetMessageEncoder(messageEncoder);
return messageData;
}
UTF8BufferedMessageData TakeBufferedReader()
{
if (bufferedReaderPool == null)
{
lock (ThisLock)
{
if (bufferedReaderPool == null)
{
bufferedReaderPool = new SynchronizedPool<UTF8BufferedMessageData>(maxReadPoolSize);
}
}
}
UTF8BufferedMessageData messageData = bufferedReaderPool.Take();
if (messageData == null)
{
messageData = new UTF8BufferedMessageData(this, maxPooledXmlReadersPerMessage);
if (TD.ReadPoolMissIsEnabled())
{
TD.ReadPoolMiss(messageData.GetType().Name);
}
}
return messageData;
}
TextBufferedMessageWriter TakeBufferedWriter()
{
if (bufferedWriterPool == null)
{
lock (ThisLock)
{
if (bufferedWriterPool == null)
{
bufferedWriterPool = new SynchronizedPool<TextBufferedMessageWriter>(maxWritePoolSize);
}
}
}
TextBufferedMessageWriter messageWriter = bufferedWriterPool.Take();
if (messageWriter == null)
{
messageWriter = new TextBufferedMessageWriter(this);
if (TD.WritePoolMissIsEnabled())
{
TD.WritePoolMiss(messageWriter.GetType().Name);
}
}
return messageWriter;
}
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;
}
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;
}
public SynchronizedPoolTest()
{
SynchronizedPool = new SynchronizedPool <string>(this, MockInnerPool.Object, TimeSpan.Zero);
DecoratedPool = SynchronizedPool;
m_sync = new AutoResetEvent(false);
}
private BinaryBufferedMessageWriter TakeBufferedWriter()
{
if (this.bufferedWriterPool == null)
{
lock (this.ThisLock)
{
if (this.bufferedWriterPool == null)
{
this.bufferedWriterPool = new SynchronizedPool<BinaryBufferedMessageWriter>(this.maxWritePoolSize);
}
}
}
BinaryBufferedMessageWriter writer = this.bufferedWriterPool.Take();
if (writer == null)
{
writer = new BinaryBufferedMessageWriter(this.binaryVersion.Dictionary);
}
return writer;
}
private XmlDictionaryWriter TakeStreamedWriter(Stream stream)
{
if (this.streamedWriterPool == null)
{
lock (this.ThisLock)
{
if (this.streamedWriterPool == null)
{
this.streamedWriterPool = new SynchronizedPool<XmlDictionaryWriter>(this.maxWritePoolSize);
}
}
}
XmlDictionaryWriter writer = this.streamedWriterPool.Take();
if (writer == null)
{
return XmlDictionaryWriter.CreateBinaryWriter(stream, this.binaryVersion.Dictionary, null, false);
}
((IXmlBinaryWriterInitializer) writer).SetOutput(stream, this.binaryVersion.Dictionary, null, false);
return writer;
}
private XmlDictionaryReader TakeStreamedReader(Stream stream)
{
if (this.streamedReaderPool == null)
{
lock (this.ThisLock)
{
if (this.streamedReaderPool == null)
{
this.streamedReaderPool = new SynchronizedPool<XmlDictionaryReader>(this.maxReadPoolSize);
}
}
}
XmlDictionaryReader reader = this.streamedReaderPool.Take();
if (reader == null)
{
return XmlDictionaryReader.CreateBinaryReader(stream, this.binaryVersion.Dictionary, this.readerQuotas, null, this.onStreamedReaderClose);
}
((IXmlBinaryReaderInitializer) reader).SetInput(stream, this.binaryVersion.Dictionary, this.readerQuotas, null, this.onStreamedReaderClose);
return reader;
}
private XmlDictionaryWriter TakeStreamedWriter(Stream stream, string startInfo, string boundary, string startUri, bool writeMessageHeaders)
{
if (this.streamedWriterPool == null)
{
lock (this.thisLock)
{
if (this.streamedWriterPool == null)
{
this.streamedWriterPool = new SynchronizedPool<XmlDictionaryWriter>(this.maxWritePoolSize);
}
}
}
XmlDictionaryWriter writer = this.streamedWriterPool.Take();
if (writer == null)
{
return XmlDictionaryWriter.CreateMtomWriter(stream, this.writeEncoding, 0x7fffffff, startInfo, boundary, startUri, writeMessageHeaders, false);
}
((IXmlMtomWriterInitializer) writer).SetOutput(stream, this.writeEncoding, 0x7fffffff, startInfo, boundary, startUri, writeMessageHeaders, false);
return writer;
}
private XmlReader TakeStreamedReader(Stream stream, string contentType)
{
if (this.streamedReaderPool == null)
{
lock (this.thisLock)
{
if (this.streamedReaderPool == null)
{
this.streamedReaderPool = new SynchronizedPool<XmlDictionaryReader>(this.maxReadPoolSize);
}
}
}
XmlDictionaryReader reader = this.streamedReaderPool.Take();
try
{
if ((contentType == null) || this.IsMTOMContentType(contentType))
{
if ((reader != null) && (reader is IXmlMtomReaderInitializer))
{
((IXmlMtomReaderInitializer) reader).SetInput(stream, MtomMessageEncoderFactory.GetSupportedEncodings(), contentType, this.readerQuotas, this.maxBufferSize, this.onStreamedReaderClose);
return reader;
}
return XmlDictionaryReader.CreateMtomReader(stream, MtomMessageEncoderFactory.GetSupportedEncodings(), contentType, this.readerQuotas, this.maxBufferSize, this.onStreamedReaderClose);
}
if ((reader != null) && (reader is IXmlTextReaderInitializer))
{
((IXmlTextReaderInitializer) reader).SetInput(stream, TextMessageEncoderFactory.GetEncodingFromContentType(contentType, this.contentEncodingMap), this.readerQuotas, this.onStreamedReaderClose);
return reader;
}
reader = XmlDictionaryReader.CreateTextReader(stream, TextMessageEncoderFactory.GetEncodingFromContentType(contentType, this.contentEncodingMap), this.readerQuotas, this.onStreamedReaderClose);
}
catch (FormatException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SFxErrorCreatingMtomReader"), exception));
}
catch (XmlException exception2)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(System.ServiceModel.SR.GetString("SFxErrorCreatingMtomReader"), exception2));
}
return reader;
}
XmlDictionaryWriter TakeStreamedWriter(Stream stream)
{
if (streamedWriterPool == null)
{
lock (ThisLock)
{
if (streamedWriterPool == null)
{
streamedWriterPool = new SynchronizedPool<XmlDictionaryWriter>(maxWritePoolSize);
}
}
}
XmlDictionaryWriter xmlWriter = streamedWriterPool.Take();
if (xmlWriter == null)
{
xmlWriter = JsonReaderWriterFactory.CreateJsonWriter(stream, this.writeEncoding, false);
}
else
{
((IXmlJsonWriterInitializer)xmlWriter).SetOutput(stream, this.writeEncoding, false);
}
return xmlWriter;
}
XmlDictionaryWriter TakeStreamedWriter(Stream stream, string startInfo, string boundary, string startUri, bool writeMessageHeaders)
{
if (streamedWriterPool == null)
{
lock (thisLock)
{
if (streamedWriterPool == null)
{
streamedWriterPool = new SynchronizedPool<XmlDictionaryWriter>(maxWritePoolSize);
}
}
}
XmlDictionaryWriter xmlWriter = streamedWriterPool.Take();
if (xmlWriter == null)
{
xmlWriter = XmlDictionaryWriter.CreateMtomWriter(stream, this.writeEncoding, int.MaxValue, startInfo, boundary, startUri, writeMessageHeaders, false);
if (TD.WritePoolMissIsEnabled())
{
TD.WritePoolMiss(xmlWriter.GetType().Name);
}
}
else
{
((IXmlMtomWriterInitializer)xmlWriter).SetOutput(stream, this.writeEncoding, int.MaxValue, startInfo, boundary, startUri, writeMessageHeaders, false);
}
return xmlWriter;
}
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;
}
XmlReader TakeStreamedReader(Stream stream, string contentType)
{
if (streamedReaderPool == null)
{
lock (thisLock)
{
if (streamedReaderPool == null)
{
streamedReaderPool = new SynchronizedPool<XmlDictionaryReader>(maxReadPoolSize);
}
}
}
XmlDictionaryReader xmlReader = streamedReaderPool.Take();
try
{
if (contentType == null || IsMTOMContentType(contentType))
{
if (xmlReader != null && xmlReader is IXmlMtomReaderInitializer)
{
((IXmlMtomReaderInitializer)xmlReader).SetInput(stream, MtomMessageEncoderFactory.GetSupportedEncodings(), contentType, this.readerQuotas, this.maxBufferSize, onStreamedReaderClose);
}
else
{
xmlReader = XmlDictionaryReader.CreateMtomReader(stream, MtomMessageEncoderFactory.GetSupportedEncodings(), contentType, this.readerQuotas, this.maxBufferSize, onStreamedReaderClose);
if (TD.ReadPoolMissIsEnabled())
{
TD.ReadPoolMiss(xmlReader.GetType().Name);
}
}
}
else
{
if (xmlReader != null && xmlReader is IXmlTextReaderInitializer)
{
((IXmlTextReaderInitializer)xmlReader).SetInput(stream, TextMessageEncoderFactory.GetEncodingFromContentType(contentType, this.contentEncodingMap), this.readerQuotas, onStreamedReaderClose);
}
else
{
xmlReader = XmlDictionaryReader.CreateTextReader(stream, TextMessageEncoderFactory.GetEncodingFromContentType(contentType, this.contentEncodingMap), this.readerQuotas, onStreamedReaderClose);
if (TD.ReadPoolMissIsEnabled())
{
TD.ReadPoolMiss(xmlReader.GetType().Name);
}
}
}
}
catch (FormatException fe)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
SR.GetString(SR.SFxErrorCreatingMtomReader), fe));
}
catch (XmlException xe)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
SR.GetString(SR.SFxErrorCreatingMtomReader), xe));
}
return xmlReader;
}
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;
}
private TextBufferedMessageWriter TakeBufferedWriter()
{
if (_bufferedWriterPool == null)
{
lock (ThisLock)
{
if (_bufferedWriterPool == null)
{
_bufferedWriterPool = new SynchronizedPool<TextBufferedMessageWriter>(_maxWritePoolSize);
}
}
}
TextBufferedMessageWriter messageWriter = _bufferedWriterPool.Take();
if (messageWriter == null)
{
messageWriter = new TextBufferedMessageWriter(this);
if (WcfEventSource.Instance.WritePoolMissIsEnabled())
{
WcfEventSource.Instance.WritePoolMiss(messageWriter.GetType().Name);
}
}
return messageWriter;
}
XmlDictionaryWriter TakeStreamedWriter(Stream stream)
{
if (streamedWriterPool == null)
{
lock (ThisLock)
{
if (streamedWriterPool == null)
{
streamedWriterPool = new SynchronizedPool<XmlDictionaryWriter>(maxWritePoolSize);
}
}
}
XmlDictionaryWriter xmlWriter = streamedWriterPool.Take();
if (xmlWriter == null)
{
xmlWriter = XmlDictionaryWriter.CreateTextWriter(stream, this.writeEncoding, false);
if (TD.WritePoolMissIsEnabled())
{
TD.WritePoolMiss(xmlWriter.GetType().Name);
}
}
else
{
((IXmlTextWriterInitializer)xmlWriter).SetOutput(stream, this.writeEncoding, false);
}
return xmlWriter;
}
private UTF8BufferedMessageData TakeBufferedReader()
{
if (_bufferedReaderPool == null)
{
lock (ThisLock)
{
if (_bufferedReaderPool == null)
{
_bufferedReaderPool = new SynchronizedPool<UTF8BufferedMessageData>(_maxReadPoolSize);
}
}
}
UTF8BufferedMessageData messageData = _bufferedReaderPool.Take();
if (messageData == null)
{
messageData = new UTF8BufferedMessageData(this, maxPooledXmlReadersPerMessage);
if (WcfEventSource.Instance.ReadPoolMissIsEnabled())
{
WcfEventSource.Instance.ReadPoolMiss(messageData.GetType().Name);
}
}
return messageData;
}
XmlReader TakeStreamedReader(Stream stream, Encoding enc)
{
if (streamedReaderPool == null)
{
lock (ThisLock)
{
if (streamedReaderPool == null)
{
streamedReaderPool = new SynchronizedPool<XmlDictionaryReader>(maxReadPoolSize);
}
}
}
XmlDictionaryReader xmlReader = streamedReaderPool.Take();
if (xmlReader == null)
{
xmlReader = XmlDictionaryReader.CreateTextReader(stream, enc, this.readerQuotas, null);
if (TD.ReadPoolMissIsEnabled())
{
TD.ReadPoolMiss(xmlReader.GetType().Name);
}
}
else
{
((IXmlTextReaderInitializer)xmlReader).SetInput(stream, enc, this.readerQuotas, onStreamedReaderClose);
}
return xmlReader;
}
JsonBufferedMessageData TakeBufferedReader()
{
if (bufferedReaderPool == null)
{
lock (ThisLock)
{
if (bufferedReaderPool == null)
{
bufferedReaderPool = new SynchronizedPool<JsonBufferedMessageData>(maxReadPoolSize);
}
}
}
JsonBufferedMessageData messageData = bufferedReaderPool.Take();
if (messageData == null)
{
messageData = new JsonBufferedMessageData(this, maxPooledXmlReadersPerMessage);
}
return messageData;
}
private 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 (WcfEventSource.Instance.WritePoolMissIsEnabled())
{
WcfEventSource.Instance.WritePoolMiss(messageWriter.GetType().Name);
}
}
return messageWriter;
}
JsonBufferedMessageWriter TakeBufferedWriter()
{
if (bufferedWriterPool == null)
{
lock (ThisLock)
{
if (bufferedWriterPool == null)
{
bufferedWriterPool = new SynchronizedPool<JsonBufferedMessageWriter>(maxWritePoolSize);
}
}
}
JsonBufferedMessageWriter messageWriter = bufferedWriterPool.Take();
if (messageWriter == null)
{
messageWriter = new JsonBufferedMessageWriter(this);
}
return messageWriter;
}
public BufferedMessageData(SynchronizedPool<RecycledMessageState> messageStatePool)
{
_messageStatePool = messageStatePool;
}
XmlDictionaryReader TakeStreamedReader(Stream stream, Encoding enc)
{
if (streamedReaderPool == null)
{
lock (ThisLock)
{
if (streamedReaderPool == null)
{
streamedReaderPool = new SynchronizedPool<XmlDictionaryReader>(maxReadPoolSize);
}
}
}
XmlDictionaryReader xmlReader = streamedReaderPool.Take();
if (xmlReader == null)
{
xmlReader = JsonReaderWriterFactory.CreateJsonReader(stream, enc, this.readerQuotas, this.onStreamedReaderClose);
}
else
{
((IXmlJsonReaderInitializer)xmlReader).SetInput(stream, enc, this.readerQuotas, this.onStreamedReaderClose);
}
return xmlReader;
}
public BufferPool(int bufferSize, int limit)
{
this.pool = new SynchronizedPool<byte[]>(limit);
this.bufferSize = bufferSize;
this.limit = limit;
}
private MtomBufferedMessageData TakeBufferedReader()
{
if (this.bufferedReaderPool == null)
{
lock (this.thisLock)
{
if (this.bufferedReaderPool == null)
{
this.bufferedReaderPool = new SynchronizedPool<MtomBufferedMessageData>(this.maxReadPoolSize);
}
}
}
MtomBufferedMessageData data = this.bufferedReaderPool.Take();
if (data == null)
{
data = new MtomBufferedMessageData(this, 2);
}
return data;
}
