IgnoreFlushAndCloseStream.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Base / MS / Internal / IO / Packaging / IgnoreFlushAndCloseStream.cs / 1305600 / IgnoreFlushAndCloseStream.cs
                        
                        
                            //------------------------------------------------------------------------------ 
//  Microsoft Avalon
//  Copyright (c) Microsoft Corporation, 2005
//
//  File:           IgnoreCloseAndFlushStream.cs 
//
//  Description:    The class is used to wrap a given stream in a way that the Flush 
//                  and Close calls to the stream are Ignored. This stream class has been 
//                  created specifically for perf improvements for the ZipPackage.
// 
//
//  History:        09/05/05 - SarjanaS - initial implementation
//-----------------------------------------------------------------------------
 
using System;
using System.IO; 
using System.Windows;                       // for ExceptionStringTable 
using MS.Internal.WindowsBase;
 
namespace MS.Internal.IO.Packaging
{
    /// 
    /// This class ignores all calls to Flush() and Close() methods 
    /// depending on whether the IgnoreFlushAndClose property is set to true
    /// or false. 
    ///  
    internal sealed class IgnoreFlushAndCloseStream : Stream
    { 
        #region Constructor

        /// 
        /// Constructor 
        /// 
        ///  
        internal IgnoreFlushAndCloseStream(Stream stream) 
        {
            if (stream == null) 
                throw new ArgumentNullException("stream");

            _stream = stream;
        } 

        #endregion Constructor 
 
        #region Properties
 
        /// 
        /// Member of the abstract Stream class
        /// 
        /// Bool, true if the stream can be read from, else false 
        public override bool CanRead
        { 
            get 
            {
                if (_disposed) 
                    return false;
                else
                    return _stream.CanRead;
            } 
        }
 
        ///  
        /// Member of the abstract Stream class
        ///  
        /// Bool, true if the stream can be seeked, else false
        public override bool CanSeek
        {
            get 
            {
                if (_disposed) 
                    return false; 
                else
                    return _stream.CanSeek; 
            }
        }

        ///  
        /// Member of the abstract Stream class
        ///  
        /// Bool, true if the stream can be written to, else false 
        public override bool CanWrite
        { 
            get
            {
                if (_disposed)
                    return false; 
                else
                    return _stream.CanWrite; 
            } 
        }
 
        /// 
        /// Member of the abstract Stream class
        /// 
        /// Long value indicating the length of the stream 
        public override long Length
        { 
            get 
            {
                ThrowIfStreamDisposed(); 
                return _stream.Length;
            }
        }
 
        /// 
        /// Member of the abstract Stream class 
        ///  
        /// Long value indicating the current position in the stream
        public override long Position 
        {
            get
            {
                ThrowIfStreamDisposed(); 
                return _stream.Position;
            } 
            set 
            {
                ThrowIfStreamDisposed(); 
                _stream.Position = value;
            }
        }
 
        #endregion Properties
 
        #region Methods 

        ///  
        /// Member of the abstract Stream class
        /// 
        /// only zero is supported
        /// only SeekOrigin.Begin is supported 
        /// zero
        public override long Seek(long offset, SeekOrigin origin) 
        { 
            ThrowIfStreamDisposed();
            return _stream.Seek(offset, origin); 
        }

        /// 
        /// Member of the abstract Stream class 
        /// 
        ///  
        public override void SetLength(long newLength) 
        {
            ThrowIfStreamDisposed(); 
            _stream.SetLength(newLength);
        }

        ///  
        /// Member of the abstract Stream class
        ///  
        ///  
        /// 
        ///  
        /// 
        /// 
        /// The standard Stream.Read semantics, and in particular the restoration of the current
        /// position in case of an exception, is implemented by the underlying stream. 
        /// 
        public override int Read(byte[] buffer, int offset, int count) 
        { 
            ThrowIfStreamDisposed();
            return _stream.Read(buffer, offset, count); 
        }

        /// 
        /// Member of the abstract Stream class 
        /// 
        ///  
        ///  
        /// 
        public override void Write(byte[] buf, int offset, int count) 
        {
            ThrowIfStreamDisposed();
            _stream.Write(buf, offset, count);
        } 

        ///  
        /// Member of the abstract Stream class 
        /// 
        public override void Flush() 
        {
            ThrowIfStreamDisposed();
        }
        #endregion Methods 

        //----------------------------------------------------- 
        // 
        //  Protected Methods
        // 
        //-----------------------------------------------------
        /// 
        /// Dispose(bool)
        ///  
        /// 
        protected override void Dispose(bool disposing) 
        { 
            try
            { 
                if (!_disposed)
                {
                    _stream = null;
                    _disposed = true; 
                }
            } 
            finally 
            {
                base.Dispose(disposing); 
            }
        }

 
        #region Private Methods
 
        private void ThrowIfStreamDisposed() 
        {
            if (_disposed) 
                throw new ObjectDisposedException(null, SR.Get(SRID.StreamObjectDisposed));
        }

        #endregion Private Methods 

        #region Private Variables 
 
        private Stream _stream;
        private bool _disposed; 

        #endregion Private Variables

    } 
}
 

// 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
IgnoreFlushAndCloseStream.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
