DelegateBodyWriter.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataWeb / Server / System / Data / Services / DelegateBodyWriter.cs / 1305376 / DelegateBodyWriter.cs
                        
                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//  
//      Provides a BodyWriter that invokes a callback on writing.
//  
// 
// @owner  [....]
//--------------------------------------------------------------------- 

namespace System.Data.Services
{
    #region Namespaces. 

    using System; 
    using System.Diagnostics; 
    using System.IO;
    using System.ServiceModel.Channels; 
    using System.Xml;

    #endregion Namespaces.
 
    /// Use this class to handle writing body contents using a callback.
    internal class DelegateBodyWriter : BodyWriter 
    { 
        #region Fields.
 
        /// Service to dispose data source from once the response is written.
        private readonly IDataService service;

        /// Callback. 
        private readonly Action writerAction;
 
        #endregion Fields. 

        /// Initializes a new  instance. 
        /// Callback for writing.
        /// Service to dispose data source from once the response is written.
        internal DelegateBodyWriter(Action writer, IDataService service)
            : base(false) 
        {
            Debug.Assert(service != null, "service != null"); 
            Debug.Assert(writer != null, "writer != null"); 
            this.writerAction = writer;
            this.service = service; 
        }

        /// Called when the message body is written to an XML file.
        ///  
        /// An  that is used to write this
        /// message body to an XML file. 
        ///  
        protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
        { 
            Debug.Assert(writer != null, "writer != null");

            try
            { 
                writer.WriteStartElement(XmlConstants.WcfBinaryElementName);
                using (XmlWriterStream stream = new XmlWriterStream(writer)) 
                { 
                    this.writerAction(stream);
                } 

                writer.WriteEndElement();
            }
            finally 
            {
                if (this.service != null) 
                { 
                    this.service.DisposeDataSource();
                    HttpContextServiceHost host = this.service.OperationContext.Host.HttpContextServiceHost; 
                    if (host != null)
                    {
                        if (host.ErrorFound)
                        { 
                            var ctx = System.ServiceModel.OperationContext.Current;
                            if (ctx != null) 
                            { 
                                ctx.Channel.Abort();
                            } 
                        }
                    }
                }
            } 
        }
 
        #region Inner types. 

        /// Use this class to write to an . 
        internal class XmlWriterStream : Stream
        {
            /// Target writer.
            private XmlDictionaryWriter innerWriter; 

            /// Initializes a new  instance. 
            /// Target writer. 
            internal XmlWriterStream(XmlDictionaryWriter xmlWriter)
            { 
                Debug.Assert(xmlWriter != null, "xmlWriter != null");
                this.innerWriter = xmlWriter;
            }
 
            /// Gets a value indicating whether the current stream supports reading.
            public override bool CanRead 
            { 
                get { return false; }
            } 

            /// Gets a value indicating whether the current stream supports seeking.
            public override bool CanSeek
            { 
                get { return false; }
            } 
 
            /// Gets a value indicating whether the current stream supports writing.
            public override bool CanWrite 
            {
                get { return true; }
            }
 
            /// Gets the length in bytes of the stream.
            public override long Length 
            { 
                get { throw Error.NotSupported(); }
            } 

            /// Gets or sets the position within the current stream.
            public override long Position
            { 
                get { throw Error.NotSupported(); }
                set { throw Error.NotSupported(); } 
            } 

            ///  
            /// Clears all buffers for this stream and causes any buffered
            /// data to be written to the underlying device.
            /// 
            public override void Flush() 
            {
                this.innerWriter.Flush(); 
            } 

            ///  
            /// Reads a sequence of bytes from the current stream and
            /// advances the position within the stream by the number of bytes read.
            /// 
            ///  
            /// An array of bytes. When this method returns, the buffer contains
            /// the specified byte array with the values between  
            /// and ( +  - 1) replaced 
            /// by the bytes read from the current source.
            ///  
            /// 
            /// The zero-based byte offset in  at which to
            /// begin storing the data read from the current stream.
            ///  
            /// 
            /// The maximum number of bytes to be read from the current stream. 
            ///  
            /// The total number of bytes read into the buffer.
            public override int Read(byte[] buffer, int offset, int count) 
            {
                throw Error.NotSupported();
            }
 
            /// Sets the position within the current stream.
            ///  
            /// A byte offset relative to the  parameter. 
            /// 
            ///  
            /// A value of type  indicating the reference
            /// point used to obtain the new position.
            /// 
            /// The new position within the current stream. 
            public override long Seek(long offset, SeekOrigin origin)
            { 
                throw Error.NotSupported(); 
            }
 
            /// Sets the length of the current stream.
            /// New value for length.
            public override void SetLength(long value)
            { 
                throw Error.NotSupported();
            } 
 
            /// 
            /// Writes a sequence of bytes to the current stream and advances 
            /// the current position within this stream by the number of
            /// bytes written.
            /// 
            ///  
            /// An array of bytes. This method copies 
            /// bytes from  to the current stream. 
            ///  
            /// 
            /// The zero-based byte offset in buffer at which to begin copying 
            /// bytes to the current stream.
            /// 
            /// 
            /// The number of bytes to be written to the current stream. 
            /// 
            public override void Write(byte[] buffer, int offset, int count) 
            { 
                this.innerWriter.WriteBase64(buffer, offset, count);
            } 
        }

        #endregion Inner types.
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
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
DelegateBodyWriter.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
