SharedStream.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Framework / System / Windows / Markup / Baml2006 / SharedStream.cs / 1305600 / SharedStream.cs
                        

                        
                            using System; 
using System.IO;
using System.ComponentModel;

namespace System.Windows.Baml2006 
{
    /// 
 
    /// Reference counted stream 
    /// Allows multiple callers independently coordinate "current position"
    /// for reads and writes on a shared stream. 
    /// Methods on this class are not thread safe.
    /// 
    internal class SharedStream : Stream
    { 
        private Stream _baseStream;
        private long _offset; 
        private long _length; 
        private long _position;
        private RefCount _refCount; 

        public SharedStream(Stream baseStream)
        {
            if (baseStream == null) 
            {
                throw new ArgumentNullException("baseStream"); 
            } 

            Initialize(baseStream, 0, baseStream.Length); 
        }

        /// 

        /// Constructor that limits the bytes that can be written to or read form 
        /// 
        ///  
        ///  
        /// 
        public SharedStream(Stream baseStream, long offset, long length) 
        {
            if (baseStream == null)
            {
                throw new ArgumentNullException("baseStream"); 
            }
 
            Initialize(baseStream, offset, length); 
        }
 
        private void Initialize(Stream baseStream, long offset, long length)
        {
            if (baseStream.CanSeek == false)
            { 
                throw new ArgumentException("can’t seek on baseStream");
            } 
 
            if (offset < 0)
            { 
                throw new ArgumentOutOfRangeException("offset");
            }

            if (length < 0) 
            {
                throw new ArgumentOutOfRangeException("length"); 
            } 

            SharedStream subStream = baseStream as SharedStream; 
            if (subStream != null)
            {
                _baseStream = subStream.BaseStream;
                _offset = offset + subStream._offset; 
                _length = length;
                _refCount = subStream._refCount; 
                _refCount.Value++; 
            }
            else 
            {
                _baseStream = baseStream;
                _offset = offset;
                _length = length; 
                _refCount = new RefCount();
                _refCount.Value++; 
            } 
        }
 
        /// 

        /// Number of clients sharing the base stream
        /// 
        public virtual int SharedCount 
        {
            get { return _refCount.Value; } 
        } 

        public override bool CanRead 
        {
            get
            {
                CheckDisposed(); 
                return _baseStream.CanRead;
            } 
        } 

        public override bool CanSeek 
        {
            get
            {
                return true; 
            }
        } 
 
        public override bool CanWrite
        { 
            get
            {
#if true
                return false; 
#else
                CheckDisposed(); 
                return _baseStream.CanWrite; 
#endif
            } 
        }

        public override void Flush()
        { 
            CheckDisposed();
            _baseStream.Flush(); 
        } 

        public override long Length 
        {
            get
            {
                return _length; 
            }
        } 
 
        public override long Position
        { 
            get
            {
                return _position;
            } 
            set
            { 
                if (value < 0 || value >= _length) 
                {
                    throw new ArgumentOutOfRangeException("value", value, string.Empty); 
                }

                _position = value;
            } 
        }
 
        public virtual bool IsDisposed { get { return _baseStream == null; } } 

        public override int ReadByte() 
        {
            CheckDisposed();

            long end = Math.Min(_position + 1, _length); 

            int b; 
            if ([....]()) 
            {
                b = _baseStream.ReadByte(); 
                _position = _baseStream.Position - _offset;
            }
            else
            { 
                b = -1;
            } 
            return b; 
        }
 
        public override int Read(byte[] buffer, int offset, int count)
        {
            if (buffer == null)
            { 
                throw new ArgumentNullException("buffer");
            } 
 
            if (offset < 0 || offset >= buffer.Length)
            { 
                throw new ArgumentOutOfRangeException("offset");
            }

            if ((offset + count) > buffer.Length) 
            {
                throw new ArgumentOutOfRangeException("count"); 
            } 

            CheckDisposed(); 

            long end = Math.Min(_position + count, _length);

            int bytesRead = 0; 

            if ([....]()) 
            { 
                bytesRead = _baseStream.Read(buffer, offset, (int)(end - _position));
                _position = _baseStream.Position - _offset; 
            }

            return bytesRead;
        } 

        public override void Write(byte[] buffer, int offset, int count) 
        { 
#if true
            throw new NotSupportedException(); 
#else
            if(buffer == null)
            {
                throw new ArgumentNullException("buffer"); 
            }
 
            if(offset < 0 || offset >= buffer.Length) { 
                throw new ArgumentOutOfRangeException("offset");
            } 

            if((offset + count) > buffer.Length) {
                throw new ArgumentOutOfRangeException("count");
            } 

            CheckDisposed(); 
 
            long end = Math.Min(_position + count, _length);
 
            if ([....]())
            {
                _baseStream.Write(buffer, offset, (int)(end - _position));
                _position = _baseStream.Position - _offset; 
            }
#endif 
        } 

        public override long Seek(long offset, SeekOrigin origin) 
        {
            long newPosition;
            switch (origin)
            { 
                case SeekOrigin.Begin:
                    newPosition = offset; 
                    break; 

                case SeekOrigin.Current: 
                    newPosition = _position + offset;
                    break;

                case SeekOrigin.End: 
                    newPosition = _length + offset;
                    break; 
 
                default:
                    throw new InvalidEnumArgumentException("origin", (int)origin, typeof(SeekOrigin)); 
            }

            if (newPosition < 0 || newPosition >= _length)
            { 
                throw new ArgumentOutOfRangeException("offset", offset, string.Empty);
            } 
 
            CheckDisposed();
 
            _position = newPosition;

            return _position;
        } 

        public override void SetLength(long value) 
        { 
            throw new NotSupportedException();
        } 

        protected override void Dispose(bool disposing)
        {
            if (disposing) 
            {
                if (_baseStream != null) 
                { 
                    _refCount.Value--;
                    if (_refCount.Value < 1) 
                    {
                        _baseStream.Close();
                    }
                    _refCount = null; 
                    _baseStream = null;
                } 
            } 

            base.Dispose(disposing); 
        }

        public Stream BaseStream
        { 
            get { return _baseStream; }
        } 
 
        private void CheckDisposed()
        { 
            if (IsDisposed)
            {
                throw new ObjectDisposedException("BaseStream");
            } 
        }
 
        private bool [....]() 
        {
            System.Diagnostics.Debug.Assert(_baseStream != null, "Stream has already been disposed"); 

            if (_position >= 0 && _position < _length)
            {
                if (_position + _offset != _baseStream.Position) 
                    _baseStream.Seek(_offset + _position, SeekOrigin.Begin);
                return true; 
            } 

            return false; 
        }

        class RefCount
        { 
            public int Value;
        } 
    } 

} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System; 
using System.IO;
using System.ComponentModel;

namespace System.Windows.Baml2006 
{
    /// 
 
    /// Reference counted stream 
    /// Allows multiple callers independently coordinate "current position"
    /// for reads and writes on a shared stream. 
    /// Methods on this class are not thread safe.
    /// 
    internal class SharedStream : Stream
    { 
        private Stream _baseStream;
        private long _offset; 
        private long _length; 
        private long _position;
        private RefCount _refCount; 

        public SharedStream(Stream baseStream)
        {
            if (baseStream == null) 
            {
                throw new ArgumentNullException("baseStream"); 
            } 

            Initialize(baseStream, 0, baseStream.Length); 
        }

        /// 

        /// Constructor that limits the bytes that can be written to or read form 
        /// 
        ///  
        ///  
        /// 
        public SharedStream(Stream baseStream, long offset, long length) 
        {
            if (baseStream == null)
            {
                throw new ArgumentNullException("baseStream"); 
            }
 
            Initialize(baseStream, offset, length); 
        }
 
        private void Initialize(Stream baseStream, long offset, long length)
        {
            if (baseStream.CanSeek == false)
            { 
                throw new ArgumentException("can’t seek on baseStream");
            } 
 
            if (offset < 0)
            { 
                throw new ArgumentOutOfRangeException("offset");
            }

            if (length < 0) 
            {
                throw new ArgumentOutOfRangeException("length"); 
            } 

            SharedStream subStream = baseStream as SharedStream; 
            if (subStream != null)
            {
                _baseStream = subStream.BaseStream;
                _offset = offset + subStream._offset; 
                _length = length;
                _refCount = subStream._refCount; 
                _refCount.Value++; 
            }
            else 
            {
                _baseStream = baseStream;
                _offset = offset;
                _length = length; 
                _refCount = new RefCount();
                _refCount.Value++; 
            } 
        }
 
        /// 

        /// Number of clients sharing the base stream
        /// 
        public virtual int SharedCount 
        {
            get { return _refCount.Value; } 
        } 

        public override bool CanRead 
        {
            get
            {
                CheckDisposed(); 
                return _baseStream.CanRead;
            } 
        } 

        public override bool CanSeek 
        {
            get
            {
                return true; 
            }
        } 
 
        public override bool CanWrite
        { 
            get
            {
#if true
                return false; 
#else
                CheckDisposed(); 
                return _baseStream.CanWrite; 
#endif
            } 
        }

        public override void Flush()
        { 
            CheckDisposed();
            _baseStream.Flush(); 
        } 

        public override long Length 
        {
            get
            {
                return _length; 
            }
        } 
 
        public override long Position
        { 
            get
            {
                return _position;
            } 
            set
            { 
                if (value < 0 || value >= _length) 
                {
                    throw new ArgumentOutOfRangeException("value", value, string.Empty); 
                }

                _position = value;
            } 
        }
 
        public virtual bool IsDisposed { get { return _baseStream == null; } } 

        public override int ReadByte() 
        {
            CheckDisposed();

            long end = Math.Min(_position + 1, _length); 

            int b; 
            if ([....]()) 
            {
                b = _baseStream.ReadByte(); 
                _position = _baseStream.Position - _offset;
            }
            else
            { 
                b = -1;
            } 
            return b; 
        }
 
        public override int Read(byte[] buffer, int offset, int count)
        {
            if (buffer == null)
            { 
                throw new ArgumentNullException("buffer");
            } 
 
            if (offset < 0 || offset >= buffer.Length)
            { 
                throw new ArgumentOutOfRangeException("offset");
            }

            if ((offset + count) > buffer.Length) 
            {
                throw new ArgumentOutOfRangeException("count"); 
            } 

            CheckDisposed(); 

            long end = Math.Min(_position + count, _length);

            int bytesRead = 0; 

            if ([....]()) 
            { 
                bytesRead = _baseStream.Read(buffer, offset, (int)(end - _position));
                _position = _baseStream.Position - _offset; 
            }

            return bytesRead;
        } 

        public override void Write(byte[] buffer, int offset, int count) 
        { 
#if true
            throw new NotSupportedException(); 
#else
            if(buffer == null)
            {
                throw new ArgumentNullException("buffer"); 
            }
 
            if(offset < 0 || offset >= buffer.Length) { 
                throw new ArgumentOutOfRangeException("offset");
            } 

            if((offset + count) > buffer.Length) {
                throw new ArgumentOutOfRangeException("count");
            } 

            CheckDisposed(); 
 
            long end = Math.Min(_position + count, _length);
 
            if ([....]())
            {
                _baseStream.Write(buffer, offset, (int)(end - _position));
                _position = _baseStream.Position - _offset; 
            }
#endif 
        } 

        public override long Seek(long offset, SeekOrigin origin) 
        {
            long newPosition;
            switch (origin)
            { 
                case SeekOrigin.Begin:
                    newPosition = offset; 
                    break; 

                case SeekOrigin.Current: 
                    newPosition = _position + offset;
                    break;

                case SeekOrigin.End: 
                    newPosition = _length + offset;
                    break; 
 
                default:
                    throw new InvalidEnumArgumentException("origin", (int)origin, typeof(SeekOrigin)); 
            }

            if (newPosition < 0 || newPosition >= _length)
            { 
                throw new ArgumentOutOfRangeException("offset", offset, string.Empty);
            } 
 
            CheckDisposed();
 
            _position = newPosition;

            return _position;
        } 

        public override void SetLength(long value) 
        { 
            throw new NotSupportedException();
        } 

        protected override void Dispose(bool disposing)
        {
            if (disposing) 
            {
                if (_baseStream != null) 
                { 
                    _refCount.Value--;
                    if (_refCount.Value < 1) 
                    {
                        _baseStream.Close();
                    }
                    _refCount = null; 
                    _baseStream = null;
                } 
            } 

            base.Dispose(disposing); 
        }

        public Stream BaseStream
        { 
            get { return _baseStream; }
        } 
 
        private void CheckDisposed()
        { 
            if (IsDisposed)
            {
                throw new ObjectDisposedException("BaseStream");
            } 
        }
 
        private bool [....]() 
        {
            System.Diagnostics.Debug.Assert(_baseStream != null, "Stream has already been disposed"); 

            if (_position >= 0 && _position < _length)
            {
                if (_position + _offset != _baseStream.Position) 
                    _baseStream.Seek(_offset + _position, SeekOrigin.Begin);
                return true; 
            } 

            return false; 
        }

        class RefCount
        { 
            public int Value;
        } 
    } 

} 

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

                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• FixedPage.cs
• MemoryResponseElement.cs
• OdbcConnectionOpen.cs
• ActionMismatchAddressingException.cs
• SiteMapPath.cs
• FindRequestContext.cs
• WindowsFormsHostPropertyMap.cs
• ValidationResult.cs
• EventLogEntryCollection.cs
• DateTimeFormatInfo.cs
• SmtpCommands.cs
• ManipulationVelocities.cs
• Journaling.cs
• ShapeTypeface.cs
• SHA512Managed.cs
• XmlSerializerVersionAttribute.cs
• WMIGenerator.cs
• PageAsyncTask.cs
• EdmComplexPropertyAttribute.cs
• FtpRequestCacheValidator.cs
• ConfigurationManagerHelper.cs
• XmlMembersMapping.cs
• BooleanAnimationUsingKeyFrames.cs
• RequiredAttributeAttribute.cs
• GridPatternIdentifiers.cs
• IndependentAnimationStorage.cs
• AttributeCollection.cs
• Error.cs
• ContextMenuStripActionList.cs
• PersonalizablePropertyEntry.cs
• StructuralType.cs
• XslTransform.cs
• GridItem.cs
• StoreItemCollection.cs
• DataGridViewRowHeaderCell.cs
• RadioButtonBaseAdapter.cs
• EntityDataSourceQueryBuilder.cs
• SelectionItemPattern.cs
• PointAnimationUsingKeyFrames.cs
• SettingsBase.cs
• hresults.cs
• SortQuery.cs
• ItemsControl.cs
• Flattener.cs
• XPathDocument.cs
• loginstatus.cs
• XmlJsonReader.cs
• TextRangeProviderWrapper.cs
• CallSiteHelpers.cs
• WebPageTraceListener.cs
• X509Utils.cs
• FreezableOperations.cs
• ForeignKeyConstraint.cs
• Matrix.cs
• AuthorizationRuleCollection.cs
• QueryOperationResponseOfT.cs
• Ipv6Element.cs
• OperationCanceledException.cs
• EventLogException.cs
• RecordsAffectedEventArgs.cs
• DbConnectionOptions.cs
• GridViewDeleteEventArgs.cs
• UnsafeNativeMethods.cs
• WorkerRequest.cs
• MediaScriptCommandRoutedEventArgs.cs
• XslCompiledTransform.cs
• Section.cs
• UIntPtr.cs
• IncrementalHitTester.cs
• MemberInfoSerializationHolder.cs
• MgmtConfigurationRecord.cs
• VoiceChangeEventArgs.cs
• RequestCacheValidator.cs
• BamlResourceDeserializer.cs
• LinkLabel.cs
• HttpProfileBase.cs
• Byte.cs
• ConstraintConverter.cs
• HwndSourceParameters.cs
• QuadraticBezierSegment.cs
• WebBrowserNavigatingEventHandler.cs
• ClipboardProcessor.cs
• _ConnectionGroup.cs
• webclient.cs
• __ComObject.cs
• SectionUpdates.cs
• DispatcherTimer.cs
• SpellerHighlightLayer.cs
• NumberSubstitution.cs
• MdImport.cs
• MetadataCache.cs
• ISessionStateStore.cs
• xdrvalidator.cs
• IdnMapping.cs
• CheckoutException.cs
• BehaviorEditorPart.cs
• TaskSchedulerException.cs
• SoapProcessingBehavior.cs
• DocumentEventArgs.cs
• DataKeyCollection.cs