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);
            }
 void ReturnMessageWriter(JsonBufferedMessageWriter messageWriter)
 {
     bufferedWriterPool.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 override ArraySegment <byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
            {
                if (message == null)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message"));
                }
                if (bufferManager == null)
                {
                    throw TraceUtility.ThrowHelperError(new ArgumentNullException("bufferManager"), message);
                }
                if (maxMessageSize < 0)
                {
                    throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxMessageSize", maxMessageSize,
                                                                                        SR2.GetString(SR2.ValueMustBeNonNegative)), message);
                }
                if (messageOffset < 0 || messageOffset > maxMessageSize)
                {
                    throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException("messageOffset", messageOffset,
                                                                                        SR2.GetString(SR2.JsonValueMustBeInRange, 0, maxMessageSize)), message);
                }

                EventTraceActivity eventTraceActivity = null;

                if (WebTD.JsonMessageEncodingStartIsEnabled())
                {
                    eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
                    WebTD.JsonMessageEncodingStart(eventTraceActivity);
                }

                ThrowIfMismatchedMessageVersion(message);
                message.Properties.Encoder = this;
                JsonBufferedMessageWriter messageWriter = TakeBufferedWriter();

                JavascriptCallbackResponseMessageProperty javascriptResponseMessageProperty;

                if (message.Properties.TryGetValue <JavascriptCallbackResponseMessageProperty>(JavascriptCallbackResponseMessageProperty.Name, out javascriptResponseMessageProperty) &&
                    javascriptResponseMessageProperty != null)
                {
                    if (this.crossDomainScriptAccessEnabled)
                    {
                        messageWriter.SetJavascriptCallbackProperty(javascriptResponseMessageProperty);
                    }
                    else
                    {
                        throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR2.JavascriptCallbackNotEnabled), message);
                    }
                }

                ArraySegment <byte> messageData = messageWriter.WriteMessage(message, bufferManager, messageOffset, maxMessageSize);

                ReturnMessageWriter(messageWriter);

                if (SMTD.MessageWrittenByEncoderIsEnabled() && messageData != null)
                {
                    SMTD.MessageWrittenByEncoder(
                        eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message),
                        messageData.Count,
                        this);
                }

                if (MessageLogger.LogMessagesAtTransportLevel)
                {
                    XmlDictionaryReader xmlDictionaryReader = JsonReaderWriterFactory.CreateJsonReader(
                        messageData.Array, messageData.Offset, messageData.Count, null, XmlDictionaryReaderQuotas.Max, null);
                    MessageLogger.LogMessage(ref message, xmlDictionaryReader, MessageLoggingSource.TransportSend);
                }

                return(messageData);
            }
 void ReturnMessageWriter(JsonBufferedMessageWriter messageWriter)
 {
     bufferedWriterPool.Return(messageWriter);
 }