MessageBuffer.cs source code in C# .NET

                        Code:
                         / WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Channels / MessageBuffer.cs / 1 / MessageBuffer.cs
                        
                        
                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Channels
{ 
    using System.Xml;
    using System.ServiceModel; 
    using System.ServiceModel.Dispatcher; 
    using System.Xml.XPath;
    using System.Diagnostics; 
    using System.IO;
    using System.Collections.Generic;

    public abstract class MessageBuffer : IXPathNavigable, IDisposable 
    {
        public abstract int BufferSize { get; } 
 
        void IDisposable.Dispose()
        { 
            Close();
        }

        public abstract void Close(); 

        public virtual void WriteMessage(Stream stream) 
        { 
            if (stream == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream")); 
            Message message = CreateMessage();
            using (message)
            {
                XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(stream, XD.Dictionary, null, false); 
                using (writer)
                { 
                    message.WriteMessage(writer); 
                }
            } 
        }

        public virtual string MessageContentType
        { 
            get { return FramingEncodingString.Binary; }
        } 
 
        public abstract Message CreateMessage();
 
        internal Exception CreateBufferDisposedException()
        {
            return new ObjectDisposedException("", SR.GetString(SR.MessageBufferIsClosed));
        } 

        public XPathNavigator CreateNavigator() 
        { 
            return CreateNavigator(int.MaxValue, XmlSpace.None);
        } 

        public XPathNavigator CreateNavigator(int nodeQuota)
        {
            return CreateNavigator(nodeQuota, XmlSpace.None); 
        }
 
        public XPathNavigator CreateNavigator(XmlSpace space) 
        {
            return CreateNavigator(int.MaxValue, space); 
        }

        public XPathNavigator CreateNavigator(int nodeQuota, XmlSpace space)
        { 
            if (nodeQuota <= 0)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("nodeQuota", SR.GetString(SR.FilterQuotaRange))); 
 
            return new SeekableMessageNavigator(this.CreateMessage(), nodeQuota, space, true, true);
        } 
    }

    class DefaultMessageBuffer : MessageBuffer
    { 
        XmlBuffer msgBuffer;
        KeyValuePair[] properties; 
        bool[] understoodHeaders; 
        bool closed;
        MessageVersion version; 

        public DefaultMessageBuffer(Message message, XmlBuffer msgBuffer)
        {
            this.msgBuffer = msgBuffer; 
            this.version = message.Version;
            properties = new KeyValuePair[message.Properties.Count]; 
            ((ICollection>)message.Properties).CopyTo(properties, 0); 
            understoodHeaders = new bool[message.Headers.Count];
            for (int i = 0; i < understoodHeaders.Length; ++i) 
                understoodHeaders[i] = message.Headers.IsUnderstood(i);
        }

        object ThisLock 
        {
            get { return msgBuffer; } 
        } 

        public override int BufferSize 
        {
            get { return msgBuffer.BufferSize; }
        }
 
        public override void Close()
        { 
            lock (ThisLock) 
            {
                if (closed) 
                    return;

                closed = true;
                for (int i = 0; i < this.properties.Length; i++) 
                {
                    IDisposable disposable = this.properties[i].Value as IDisposable; 
                    if (disposable != null) 
                        disposable.Dispose();
                } 
            }
        }

        public override Message CreateMessage() 
        {
            if (closed) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException()); 

            Message msg = Message.CreateMessage(msgBuffer.GetReader(0), int.MaxValue, this.version); 
            lock (ThisLock)
            {
                msg.Properties.CopyProperties(properties);
            } 

            for (int i = 0; i < understoodHeaders.Length; ++i) 
            { 
                if (understoodHeaders[i])
                    msg.Headers.AddUnderstood(i); 
            }

            return msg;
        } 
    }
 
    class BufferedMessageBuffer : MessageBuffer 
    {
        IBufferedMessageData messageData; 
        KeyValuePair[] properties;
        bool closed;
        object thisLock = new object();
        bool[] understoodHeaders; 

        public BufferedMessageBuffer(IBufferedMessageData messageData, 
            KeyValuePair[] properties, bool[] understoodHeaders) 
        {
            this.messageData = messageData; 
            this.properties = properties;
            this.understoodHeaders = understoodHeaders;
            messageData.Open();
        } 

        public override int BufferSize 
        { 
            get
            { 
                lock (ThisLock)
                {
                    if (closed)
#pragma warning suppress 56503 // [....], Invalid State after dispose 
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
                    return messageData.Buffer.Count; 
                } 
            }
        } 

        public override void WriteMessage(Stream stream)
        {
            if (stream == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
            lock (ThisLock) 
            { 
                if (closed)
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException()); 
                ArraySegment buffer = messageData.Buffer;
                stream.Write(buffer.Array, buffer.Offset, buffer.Count);
            }
        } 

        public override string MessageContentType 
        { 
            get
            { 
                lock (ThisLock)
                {
                    if (closed)
#pragma warning suppress 56503 // [....], Invalid State after dispose 
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
                    return messageData.MessageEncoder.ContentType; 
                } 
            }
        } 

        object ThisLock
        {
            get { return thisLock; } 
        }
 
        public override void Close() 
        {
            lock (ThisLock) 
            {
                if (!closed)
                {
                    closed = true; 
                    messageData.Close();
                    messageData = null; 
                } 
            }
        } 

        public override Message CreateMessage()
        {
            lock (ThisLock) 
            {
                if (closed) 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException()); 
                RecycledMessageState recycledMessageState = messageData.TakeMessageState();
                if (recycledMessageState == null) 
                    recycledMessageState = new RecycledMessageState();
                BufferedMessage bufferedMessage = new BufferedMessage(messageData, recycledMessageState, this.understoodHeaders);
                bufferedMessage.Properties.CopyProperties(this.properties);
                messageData.Open(); 
                return bufferedMessage;
            } 
        } 
    }
 
    class BodyWriterMessageBuffer : MessageBuffer
    {
        BodyWriter bodyWriter;
        KeyValuePair[] properties; 
        MessageHeaders headers;
        bool closed; 
        object thisLock = new object(); 

        public BodyWriterMessageBuffer(MessageHeaders headers, 
            KeyValuePair[] properties, BodyWriter bodyWriter)
        {
            this.bodyWriter = bodyWriter;
            this.headers = new MessageHeaders(headers); 
            this.properties = properties;
        } 
 
        protected object ThisLock
        { 
            get { return thisLock; }
        }

        public override int BufferSize 
        {
            get { return 0; } 
        } 

        public override void Close() 
        {
            lock (ThisLock)
            {
                if (!closed) 
                {
                    closed = true; 
                    bodyWriter = null; 
                    headers = null;
                    properties = null; 
                }
            }
        }
 
        public override Message CreateMessage()
        { 
            lock (ThisLock) 
            {
                if (closed) 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateBufferDisposedException());
                return new BodyWriterMessage(headers, properties, bodyWriter);
            }
        } 

        protected BodyWriter BodyWriter 
        { 
            get { return bodyWriter; }
        } 

        protected MessageHeaders Headers
        {
            get { return headers; } 
        }
 
        protected KeyValuePair[] Properties 
        {
            get { return properties; } 
        }

        protected bool Closed
        { 
            get { return closed; }
        } 
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
MessageBuffer.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
