Esempio n. 1
0
        /// <summary>
        /// Initialized a new text writer over the message payload stream.
        /// </summary>
        /// <remarks>This can only be called if the text writer was not yet initialized or it has been closed.
        /// It can be called several times with CloseWriter calls in between though.</remarks>
        private void InitializeTextWriter()
        {
            // We must create the text writer over a stream which will ignore Dispose, since we need to be able to Dispose
            // the writer without disposing the underlying message stream.
            Stream nonDisposingStream;

#if NETSTANDARD1_1
            if (MessageStreamWrapper.IsNonDisposingStream(this.stream) || this.stream is AsyncBufferedStream)
#else
            if (MessageStreamWrapper.IsNonDisposingStream(this.stream))
#endif
            {
                // AsyncBufferedStream ignores Dispose
                nonDisposingStream = this.stream;
            }
            else
            {
                nonDisposingStream = MessageStreamWrapper.CreateNonDisposingStream(this.stream);
            }

            this.textWriter = new StreamWriter(nonDisposingStream, this.encoding)
            {
                NewLine = this.settings.MultipartNewLine
            };
            this.jsonWriter = new JsonWriter(this.textWriter, isIeee754Compatible: false);
        }
Esempio n. 2
0
        /// <summary>
        /// Synchronously get the stream backing this message.
        /// </summary>
        /// <param name="messageStreamFunc">A function that returns the stream backing the message.</param>
        /// <param name="isRequest">true if the message is a request message; false for a response message.</param>
        /// <returns>The <see cref="Stream"/> backing the message.</returns>
        protected internal Stream GetStream(Func <Stream> messageStreamFunc, bool isRequest)
        {
            // Check whether we have an existing buffering read stream when reading
            if (!this.writing)
            {
                BufferingReadStream existingBufferingReadStream = this.TryGetBufferingReadStream();
                if (existingBufferingReadStream != null)
                {
                    Debug.Assert(this.useBufferingReadStream.HasValue, "UseBufferingReadStream must have been set.");
                    return(existingBufferingReadStream);
                }
            }

            // Get the message stream
            Stream messageStream = messageStreamFunc();

            ValidateMessageStream(messageStream, isRequest);

            // When reading, wrap the stream in a byte counting stream if a max message size was specified.
            // When requested, wrap the stream in a non-disposing stream.
            bool needByteCountingStream = !this.writing && this.maxMessageSize > 0;

            if (!this.enableMessageStreamDisposal && needByteCountingStream)
            {
                messageStream = MessageStreamWrapper.CreateNonDisposingStreamWithMaxSize(messageStream, this.maxMessageSize);
            }
            else if (!this.enableMessageStreamDisposal)
            {
                messageStream = MessageStreamWrapper.CreateNonDisposingStream(messageStream);
            }
            else if (needByteCountingStream)
            {
                messageStream = MessageStreamWrapper.CreateStreamWithMaxSize(messageStream, this.maxMessageSize);
            }

            // If a buffering read stream is required, create it now
            if (!this.writing && this.useBufferingReadStream == true)
            {
                Debug.Assert(!this.writing, "The buffering read stream should only be used when reading.");
                this.bufferingReadStream = new BufferingReadStream(messageStream);
                messageStream            = this.bufferingReadStream;
            }

            return(messageStream);
        }
Esempio n. 3
0
        private void InitializeTextWriter()
        {
            // We must create the text writer over a stream which will ignore Dispose, since we need to be able to Dispose
            // the writer without disposing the underlying message stream.
            Stream nonDisposingStream;

            if (MessageStreamWrapper.IsNonDisposingStream(this.stream) || this.stream is AsyncBufferedStream)
            {
                // AsynBufferedStream ignores Dispose
                nonDisposingStream = this.stream;
            }
            else
            {
                nonDisposingStream = MessageStreamWrapper.CreateNonDisposingStream(this.stream);
            }

            this.textWriter = new StreamWriter(nonDisposingStream, this.encoding);
        }
Esempio n. 4
0
        /// <summary>
        /// Asynchronously get the stream backing this message.
        /// </summary>
        /// <param name="streamFuncAsync">A function that returns a task for the stream backing the message.</param>
        /// <param name="isRequest">true if the message is a request message; false for a response message.</param>
        /// <returns>A task that when completed returns the stream backing the message.</returns>
        protected internal Task <Stream> GetStreamAsync(Func <Task <Stream> > streamFuncAsync, bool isRequest)
        {
            // Check whether we have an existing buffering read stream when reading
            if (!this.writing)
            {
                Stream existingBufferingReadStream = this.TryGetBufferingReadStream();
                Debug.Assert(!this.writing || existingBufferingReadStream == null, "The buffering read stream should only be used when reading.");
                if (existingBufferingReadStream != null)
                {
                    Debug.Assert(this.useBufferingReadStream.HasValue, "UseBufferingReadStream must have been set.");
                    return(TaskUtils.GetCompletedTask(existingBufferingReadStream));
                }
            }

            Task <Stream> task = streamFuncAsync();

            ValidateMessageStreamTask(task, isRequest);

            // Wrap it in a non-disposing stream if requested
            task = task.FollowOnSuccessWith(
                streamTask =>
            {
                Stream messageStream = streamTask.Result;
                ValidateMessageStream(messageStream, isRequest);

                // When reading, wrap the stream in a byte counting stream if a max message size was specified.
                // When requested, wrap the stream in a non-disposing stream.
                bool needByteCountingStream = !this.writing && this.maxMessageSize > 0;
                if (!this.enableMessageStreamDisposal && needByteCountingStream)
                {
                    messageStream = MessageStreamWrapper.CreateNonDisposingStreamWithMaxSize(messageStream, this.maxMessageSize);
                }
                else if (!this.enableMessageStreamDisposal)
                {
                    messageStream = MessageStreamWrapper.CreateNonDisposingStream(messageStream);
                }
                else if (needByteCountingStream)
                {
                    messageStream = MessageStreamWrapper.CreateStreamWithMaxSize(messageStream, this.maxMessageSize);
                }

                return(messageStream);
            });

            // When we are reading, also buffer the input stream
            if (!this.writing)
            {
                task = task
                       .FollowOnSuccessWithTask(
                    streamTask =>
                {
                    return(BufferedReadStream.BufferStreamAsync(streamTask.Result));
                })
                       .FollowOnSuccessWith(
                    streamTask =>
                {
                    BufferedReadStream bufferedReadStream = streamTask.Result;
                    return((Stream)bufferedReadStream);
                });

                // If requested also create a buffering stream for payload kind detection
                if (this.useBufferingReadStream == true)
                {
                    task = task.FollowOnSuccessWith(
                        streamTask =>
                    {
                        Stream messageStream     = streamTask.Result;
                        this.bufferingReadStream = new BufferingReadStream(messageStream);
                        messageStream            = this.bufferingReadStream;
                        return(messageStream);
                    });
                }
            }

            return(task);
        }