BodyWriter.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Channels / BodyWriter.cs / 1 / BodyWriter.cs

                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Channels
{ 
    using System.Xml;
    using System.Diagnostics; 
 
    public abstract class BodyWriter
    { 
        bool isBuffered;
        bool canWrite;
        object thisLock;
 
        protected BodyWriter(bool isBuffered)
        { 
            this.isBuffered = isBuffered; 
            this.canWrite = true;
            if (!this.isBuffered) 
            {
                this.thisLock = new object();
            }
        } 

        public bool IsBuffered 
        { 
            get { return this.isBuffered; }
        } 

        internal virtual bool IsEmpty
        {
            get { return false; } 
        }
 
        internal virtual bool IsFault 
        {
            get { return false; } 
        }

        public BodyWriter CreateBufferedCopy(int maxBufferSize)
        { 
            if (maxBufferSize < 0)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxBufferSize", maxBufferSize, 
                                                    SR.GetString(SR.ValueMustBeNonNegative))); 
            if (this.isBuffered)
            { 
                return this;
            }
            else
            { 
                lock (this.thisLock)
                { 
                    if (!this.canWrite) 
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.BodyWriterCanOnlyBeWrittenOnce)));
                    this.canWrite = false; 
                }
                BodyWriter bodyWriter = OnCreateBufferedCopy(maxBufferSize);
                if (!bodyWriter.IsBuffered)
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.BodyWriterReturnedIsNotBuffered))); 
                return bodyWriter;
            } 
        } 

        protected virtual BodyWriter OnCreateBufferedCopy(int maxBufferSize) 
        {
            return OnCreateBufferedCopy(maxBufferSize, XmlDictionaryReaderQuotas.Max);
        }
 
        internal BodyWriter OnCreateBufferedCopy(int maxBufferSize, XmlDictionaryReaderQuotas quotas)
        { 
            XmlBuffer buffer = new XmlBuffer(maxBufferSize); 
            using (XmlDictionaryWriter writer = buffer.OpenSection(quotas))
            { 
                writer.WriteStartElement("a");
                OnWriteBodyContents(writer);
                writer.WriteEndElement();
            } 
            buffer.CloseSection();
            buffer.Close(); 
            return new BufferedBodyWriter(buffer); 
        }
 
        protected abstract void OnWriteBodyContents(XmlDictionaryWriter writer);

        public void WriteBodyContents(XmlDictionaryWriter writer)
        {		 
            if (writer == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("writer")); 
            if (!this.isBuffered) 
            {
                lock (this.thisLock) 
                {
                    if (!this.canWrite)
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.BodyWriterCanOnlyBeWrittenOnce)));
                    this.canWrite = false; 
                }
            } 
            OnWriteBodyContents(writer); 
        }
 
        class BufferedBodyWriter : BodyWriter
        {
            XmlBuffer buffer;
 
            public BufferedBodyWriter(XmlBuffer buffer) : base(true)
            { 
                this.buffer = buffer; 
            }
 
            protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
            {
                XmlDictionaryReader reader = this.buffer.GetReader(0);
                using (reader) 
                {
                    reader.ReadStartElement(); 
                    while (reader.NodeType != XmlNodeType.EndElement) 
                    {
                        writer.WriteNode(reader, false); 
                    }
                    reader.ReadEndElement();
                }
            } 
        }
    } 
} 

// 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