Пример #1
0
        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.disableMessageStreamDisposal && needByteCountingStream)
            {
                messageStream = MessageStreamWrapper.CreateNonDisposingStreamWithMaxSize(messageStream, this.maxMessageSize);
            }
            else if (this.disableMessageStreamDisposal)
            {
                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);
        }
        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);
        }
Пример #3
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.disableMessageStreamDisposal && needByteCountingStream)
                {
                    messageStream = MessageStreamWrapper.CreateNonDisposingStreamWithMaxSize(messageStream, this.maxMessageSize);
                }
                else if (this.disableMessageStreamDisposal)
                {
                    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);
        }