A replacement for MemoryStream

m_ImageSet = info.GetValue("Data", GetType(Byte()))
    '   See if the deserialized ImageSet (DICOM Image) is full of data 
    If (m_ImageSet.Length > 0) Then
        '   Create an in memory copy of the bytes
        Using tStream As New MemoryTributary(m_ImageSet)
            '   Load the DicomFile from the byte stream
            m_DicomFile = Dicom.DicomFile.Open(tStream)
            If (m_DicomFile IsNot Nothing) Then
                '   Load the image from Dicom.DataSet
                m_DicomImage = New DicomImage(m_DicomFile.Dataset)
                If (m_DicomImage IsNot Nothing) Then
                    '   Do some work here....
                Else
                    Throw New InvalidDicomFileException("DicomImage was Null and must be set before use.")
                End If
            Else
                Throw New InvalidDicomFileException("DicomFile was Null and must be set before use.")
            End If
            tStream.Flush()
            tStream.Close()
        End Using
    End If

System.IO.EndOfStreamException occurred
  HResult=-2147024858
  Message=Unable to read beyond the end of the stream.
  Source=mscorlib
  StackTrace:
       at System.IO.__Error.EndOfFile()
       at System.IO.BinaryReader.FillBuffer(Int32 numBytes)
       at System.IO.BinaryReader.ReadUInt16()
       at Dicom.IO.StreamByteSource.GetUInt16() in C:\fo-dicom\DICOM\IO\StreamByteSource.cs:line 169
  InnerException: 

Quote:

Programmers try too hard to avoid using a file. The difference between memory and a file is a very small one in Windows. Any memory you use for a MemoryStream in fact requires a file. The storage is backed by the paging file, c:\pagefile.sys. And the reverse is true as well, any file you use is backed by memory. File data is cached in RAM by the file system cache. So if the machine has sufficient RAM then you will in fact only read and write from/to memory if you use a FileStream. And get the perf you expect from using memory. It is entirely free, you don't have to write any code to enable this nor do you have to manage it.

If the machine doesn't have enough RAM then it deteriorates the same way. When you use a MemoryStream then the paging file starts trashing and you'll be slowed down by the disk. When you use a file then the data won't fit the file system cache and you'll be slowed down by the disk.

You'll of course get the benefit of using a file, you won't run out of memory anymore. Use a FileStream instead.

MemoryTributary ms = new MemoryTributary();
//... ms is being filled by huge amount of data (about 1.2GB).
//'..Everything is OK

//Now I'm trying to Gzip it:
var outStream = new System.IO.MemoryStream();
 using (GZipStream gzip = new GZipStream(outStream, CompressionMode.Compress, true)) {
              ms.CopyTo(gzip);
              s = System.Text.Encoding.ASCII.GetString(outStream.ToArray());
          }

#region Stream Classes

    #region EnumerableByteStream

    public class EnumerableByteStream : IEnumerable<byte>, IEnumerator<byte>, IList<byte>
    {
        protected System.IO.Stream m_Stream;

        internal protected readonly long m_VirtualIndex, m_VirtualCount;

        internal protected int m_Current;

        internal protected bool m_Disposed;

        public bool Read { get { return m_Current != -1; } }

        public int CurrentInt { get { return m_Current; } }

        public byte Current { get { return (byte)m_Current; } }

        public bool CanSeek { get { return m_Stream.CanSeek; } }

        public EnumerableByteStream(byte Byte) : this(Byte.Yield()) { }

        public EnumerableByteStream(IEnumerable<byte> bytes, int? index = null, int? count = null)
            : this(new System.IO.MemoryStream(bytes.ToArray(), index ?? 0, count ?? bytes.Count()), index, count) { }

        public EnumerableByteStream(System.IO.Stream stream, int? index = null, int? count = null)
        {
            if (stream == null) throw new ArgumentNullException();
            else if (!stream.CanRead && count > 0) throw new InvalidOperationException("The given stream must be able to read to offset from the beginning");

            m_Stream = stream;

            if (index.HasValue)
            {
                if (index > m_Stream.Length) throw new InvalidOperationException("Index must be less than stream.Length");
                else m_VirtualIndex = (long)index;

                if (m_VirtualIndex != 0)
                {
                    if ((index != stream.Position && !stream.CanSeek)) throw new InvalidOperationException("Can only avdance a stream which can seek and a 0 based index was given which was not equal to the Position of the stream");
                    else m_VirtualIndex = stream.Length - stream.Seek((long)index, System.IO.SeekOrigin.Begin);
                }
            }
            else m_VirtualIndex = stream.Position;

            if (count.HasValue)
            {
                if (count + m_VirtualIndex < 0 && count + m_VirtualIndex > m_Stream.Length) throw new InvalidOperationException("Index must be greater than 0 and less than stream.Length");
                else m_VirtualCount = (long)count;
            }
            else m_VirtualCount = stream.Length;
        }

        public IEnumerable<byte> ToArray(int offset, int count, byte[] buffer)
        {
            if (offset < 0) throw new ArgumentOutOfRangeException("offset must refer to a location within the buffer.");
            else if (count + offset > Length) throw new ArgumentOutOfRangeException("count must refer to a location within the buffer with respect to offset.");

            if (count == 0) return Enumerable.Empty<byte>();
            buffer = buffer ?? new byte[count];
            int len = count;
            while ((len -= m_Stream.Read(buffer, offset, count)) > 0
                &&
                m_VirtualCount != -1 ? m_VirtualIndex < m_VirtualCount : true)
            {
                //
            }
            return buffer;
        }

        public IEnumerator<byte> GetEnumerator()
        {
            if (m_Stream.CanSeek) Reset();
            while (!m_Disposed && MoveNext()) yield return (byte)m_Current;
        }

        public bool MoveNext() { return CoreGetEnumerator() != -1; }

        int CoreGetEnumerator(long direction = 1)
        {
            if (!m_Disposed && m_Stream.CanRead && m_Stream.Position < m_Stream.Length)
            {
                //Stop the enumeration if we are past the virtual index by indicating -1
                if (m_Stream.Position >= Count) m_Current = -1;
                else m_Current = m_Stream.ReadByte();
            }
            else m_Current = -1;
            return m_Current;
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }

        internal protected long CoreIndexOf(IEnumerable<byte> items, int start = -1, int count = -1)
        {
            if (m_Stream == null || m_Disposed || items == null || items == Enumerable.Empty<byte>() || count == 0) return -1;
            if (count == -1) count = items.Count();

            if (!Read && !MoveNext()) return -1;

            if (start != -1 && start + count > Count) return -1;
            else if (start != -1 && start != Position) if (m_Stream.CanSeek) m_Stream.Seek(start, System.IO.SeekOrigin.Begin);
                else return -1;//throw new InvalidOperationException("The underlying stream must be able to seek if the start index is specified and not equal to -1");

            using (IEnumerator<byte> itemPointer = items.Skip(start).Take(count).GetEnumerator())
            {
                if (!itemPointer.MoveNext()) return -1;
                //We start at 
                long position = Position;
                if (start == -1 && m_Stream.CanSeek && m_Stream.Position != 0 && itemPointer.Current != Current)
                {
                    m_Stream.Seek((long)m_VirtualIndex, System.IO.SeekOrigin.Begin);
                    Reset();
                }
                else start = (int)m_Stream.Position;
                //While there is an itemPointer
                while (itemPointer != null)
                {
                    int j = count;
                    while (itemPointer.Current == Current && (--j > 0))
                    {
                        if (!itemPointer.MoveNext()) break;
                    }
                    //The match is complete
                    if (j == 0)
                    {
                        //If CanSeek and moved the position and we will go back to where we were
                        //if (m_Stream.CanSeek && position != Position) m_Stream.Seek(position, System.IO.SeekOrigin.Begin); //Curent and Begin need to be aware...
                        return m_Stream.Position - 1; //-1 Because a byte was read to obtain Current
                    }
                    if (!MoveNext()) break;
                }
                if (start == -1 && m_Stream.CanSeek && position != Position) m_Stream.Seek(position, System.IO.SeekOrigin.Begin);
                return -1;
            }
        }

        internal protected int CoreIndexOf(byte item, int start, int count) { return (int)CoreIndexOf(item.Yield(), start, count); }

        public virtual int IndexOf(byte item)
        {
            return CoreIndexOf(item, -1, 1);
        }

        public virtual void Insert(int index, byte item)
        {

            //System.IO.MemoryStream newMemory = new System.IO.MemoryStream(Count + 1);
            //System.IO.Stream oldMemory;
            //using (EnumerableByteStream preSegment = new EnumerableByteStream(m_Stream, 0, index - 1))
            //{
            //    using (EnumerableByteStream postSegment = new EnumerableByteStream(m_Stream, index - 1, Count - index + 1))
            //    {
            //        foreach (byte b in preSegment) newMemory.WriteByte(b);
            //        newMemory.WriteByte(item);
            //        foreach (byte b in postSegment) newMemory.WriteByte(b);
            //    }
            //}
            //oldMemory = m_Stream;
            //m_Stream = newMemory;
            //oldMemory.Dispose();

            //Linked stream around origional bytes up to index
            //additional byte
            //Rest of old stream
            //long preInsert = m_Stream.Position;
            m_Stream = LinkedStream.LinkAll(new EnumerableByteStream(m_Stream, 0, index - 1), new EnumerableByteStream(item), new EnumerableByteStream(m_Stream, index - 1, Count - index + 1));
            //m_Stream.Position = preInsert;
        }

        public virtual void RemoveAt(int index)
        {
            //Linked stream around index
            m_Stream = LinkedStream.LinkAll(new EnumerableByteStream(m_Stream, 0, index), new EnumerableByteStream(m_Stream, ++index, Count - index));
        }

        /// <summary>
        /// Sets or Retrieves a byte from the underlying stream
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public virtual byte this[int index]
        {
            get
            {
                if (index < 1) index = 0;
                if (index != m_Stream.Position)
                {
                    if (m_Stream.CanSeek) m_Stream.Seek(index, System.IO.SeekOrigin.Begin);
                    else throw new InvalidOperationException("You can only move the index if the underlying stream CanSeek");
                }
                return (byte)m_Stream.ReadByte();
            }
            set
            {
                if (m_Stream.CanWrite && m_Stream.CanSeek) m_Stream.Seek(index, System.IO.SeekOrigin.Begin);
                else throw new InvalidOperationException("You can logically set a byte in the stream the index if the underlying stream supports CanWrite and CanSeek");
                m_Stream.Write(value.Yield().ToArray(), 0, 1);
            }
        }

        public virtual void Add(byte item)
        {
            if (m_Stream.CanWrite) m_Stream.Write(item.Yield().ToArray(), 0, 1);
            else throw new InvalidOperationException("You can logically set a byte in the stream the index if the underlying stream supports CanWrite");
        }

        /// <summary>
        /// Erases all bytes in perspective of the EnumerableByteStream
        /// </summary>
        /// <remarks>
        /// Creates a new <see cref="System.IO.MemoryStream"/> in the place of the m_Stream.
        /// </remarks>
        public virtual void Clear()
        {
            m_Stream = new System.IO.MemoryStream();
            return;
        }

        public virtual bool Contains(byte item)
        {
            //See CachingEnumerableByteStream on why not < -1
            return CoreIndexOf(item, 0, 1) != -1;
        }

        /// <summary>
        /// Advanced the underlying System.IO.Stream by reading into the given array
        /// </summary>
        /// <param name="array">The array to read into</param>
        /// <param name="arrayIndex">The index into the given array to stary copying at</param>
        public virtual void CopyTo(byte[] array, int arrayIndex)
        {
            CoreCopyTo(array, arrayIndex);
        }

        public virtual void CoreCopyTo(byte[] array, int arrayIndex, int length = -1)
        {
            if (length <= 0) return;
            if (length == -1) length = array.Length - arrayIndex;
            else if (length > m_Stream.Length) throw new ArgumentOutOfRangeException("Can't copy more bytes then are availble from the stream");
            m_Stream.Read(array, arrayIndex, length);
        }

        public long Position { get { return m_VirtualIndex; } }

        public virtual long Length
        {
            get { return m_VirtualCount != -1 ? m_VirtualCount : m_Stream.Length; }
        }

        public int Count { get { return (int)Length; } }

        public virtual bool IsReadOnly
        {
            get { return m_Stream.CanWrite; }
        }

        public virtual bool Remove(byte item)
        {
            //Create N new EnumerableByteStreams with the items index noted in each iteration.
            //For each occurance of item in the underlying stream place an index
            //For each index create a new EnumerableByteStream with the index = i and the count = 1
            //m_Stream = new LinkedStream(parts)
            //return true if any of this happened 
            return false;
        }

        public static implicit operator System.IO.Stream(EnumerableByteStream eByteStream) { return eByteStream.m_Stream; }

        public void Dispose()
        {
            m_Disposed = true;
            m_Stream.Dispose();
        }

        object System.Collections.IEnumerator.Current
        {
            get { return GetEnumerator().Current; }
        }

        void System.Collections.IEnumerator.Reset()
        {
            m_Current = -1;
            if (m_Stream.CanSeek) m_Stream.Seek(m_VirtualIndex, System.IO.SeekOrigin.Begin);
        }

        public void Reset()
        {
            (this as System.Collections.IEnumerator).Reset();
        }

        public long Seek(long offset, System.IO.SeekOrigin origin) { if (m_Stream.CanSeek) return m_Stream.Seek(offset, origin); return m_Stream.Position; }
    }

    #endregion

    #region CachingEnumerableByteStream

    //Todo Test and Complete, use LinkedStream if required
    //Aims to be a type of constrained stream as well give the ability to cache previous read bytes which may no longer be able to be read from the stream
    public class CachingEnumerableByteStream : EnumerableByteStream
    {
        //Same as above but with a Cache for previously read bytes
        List<byte> m_ReadCache = new List<byte>(), m_WriteCache = new List<byte>();

        public CachingEnumerableByteStream(System.IO.Stream stream)
            : base(stream)
        {
        }

        internal void EnsureCache(int index)
        {
            try
            {
                //Read Ahead
                if (index > m_ReadCache.Count)
                {
                    byte[] buffer = new byte[index - m_Stream.Position];
                    CopyTo(buffer, 0);
                    m_ReadCache.AddRange(buffer);
                }
            }
            catch { throw; }
        }

        public override byte this[int index]
        {
            get
            {
                EnsureCache(index);
                return m_ReadCache[index];
            }
            set
            {
                //Read Ahead
                EnsureCache(index);
                base[index] = m_ReadCache[index] = value;
            }
        }
    }

    #endregion

    #region LinkedStream

    /// <summary>
    /// Represtents multiple streams as a single stream.
    /// </summary>
    /// <remarks>
    /// Turning into a interesting little looping buffer when you just call AsPerpetual, would be a cool idea for a RingBuffer
    /// </remarks>
    public class LinkedStream :
        System.IO.Stream, //LinkedStream is a System.IO.Stream
        IEnumerable<EnumerableByteStream>, //Which happens to be IEnumerable of more Stream's
        IEnumerator<EnumerableByteStream>, //It can maintain the state of those Stream's which it is IEnumerable
        IEnumerable<byte>, //It can be thought of as a single contagious allocation of memory to callers
        IEnumerator<byte>//It can maintain a state of those bytes in which it enumerates
    {
        #region Fields

        internal protected IEnumerable<EnumerableByteStream> m_Streams;

        internal protected ulong m_AbsolutePosition;

        internal protected IEnumerator<EnumerableByteStream> m_Enumerator;

        internal EnumerableByteStream m_CurrentStream;

        internal int m_StreamIndex = 0;

        internal protected bool m_Disposed;

        #endregion

        #region Propeties

        public System.IO.Stream CurrentStream
        {
            get
            {
                if (m_Disposed) return null;
                if (m_CurrentStream == null) m_CurrentStream = m_Enumerator.Current;
                return m_CurrentStream;
            }
        }

        public override bool CanRead
        {
            get { return !m_Disposed && CurrentStream.CanRead; }
        }

        public override bool CanSeek
        {
            get { return !m_Disposed && CurrentStream.CanSeek; }
        }

        public override bool CanWrite
        {
            get { return !m_Disposed && CurrentStream.CanWrite; }
        }

        public override void Flush()
        {
            if (!m_Disposed) CurrentStream.Flush();
        }

        public override long Length
        {
            get { return (long)TotalLength; }
        }

        public ulong TotalLength
        {
            get
            {
                if (m_Disposed) return 0;
                ulong totalLength = 0;
                foreach (EnumerableByteStream stream in this as IEnumerable<EnumerableByteStream>) totalLength += (ulong)(stream.Count);
                return totalLength;
            }
        }

        public override long Position
        {
            get
            {
                return (long)TotalPosition;
            }
            set
            {
                if (!m_Disposed) SeekAbsolute(value, System.IO.SeekOrigin.Current);
            }
        }

        public ulong TotalPosition
        {
            ///The total position is the m_AbsolutePosition and the currentPosition which is free roaming
            get { return m_Disposed ? 0 : m_AbsolutePosition + (ulong)m_CurrentStream.Position; }
            protected internal set { if (m_Disposed) return; m_AbsolutePosition = value; }
        }

        #endregion

        #region Constructors

        public LinkedStream(IEnumerable<EnumerableByteStream> streams)
        {
            if (streams == null) streams = Enumerable.Empty<EnumerableByteStream>();
            m_Streams = streams;
            m_Enumerator = GetEnumerator();
            m_Enumerator.MoveNext();
        }

        public LinkedStream(EnumerableByteStream stream) : this(stream.Yield()) { }


        public static LinkedStream LinkAll(params EnumerableByteStream[] streams) { return new LinkedStream(streams); }

        #endregion

        #region Methods

        /// <summary>
        /// Creates a new MemoryStream with the contents of all sub streams
        /// </summary>
        /// <returns>The resulting MemoryStream</returns>
        public System.IO.MemoryStream Flatten()
        {
            System.IO.MemoryStream memory = new System.IO.MemoryStream((int)TotalLength);
            foreach (System.IO.Stream stream in m_Streams) stream.CopyTo(memory);
            return memory;
        }

        public LinkedStream Link(params EnumerableByteStream[] streams) { return new LinkedStream(m_Streams.Concat(streams)); }

        public LinkedStream Link(EnumerableByteStream stream) { return Link(stream.Yield().ToArray()); }

        public LinkedStream Unlink(int streamIndex, bool reverse = false)
        {
            if (streamIndex > m_Streams.Count()) throw new ArgumentOutOfRangeException("index cannot be greater than the amount of contained streams");
            IEnumerable<EnumerableByteStream> streams = m_Streams;
            if (reverse) streams.Reverse();
            return new LinkedStream(m_Streams.Skip(streamIndex));
        }

        public LinkedStream SubStream(ulong absoluteIndex, ulong count)
        {

            LinkedStream result = new LinkedStream(new EnumerableByteStream(new System.IO.MemoryStream()));

            if (count == 0) return result;

            while (absoluteIndex > 0)
            {
                //absoluteIndex -= Read(// StreamOverload
            }

            return result;
        }

        internal void SelectStream(int logicalIndex)
        {
            if (m_Disposed) return;
            //If the stream is already selected return
            if (m_StreamIndex == logicalIndex) return;
            else if (logicalIndex < m_StreamIndex) m_Enumerator.Reset(); //If the logicalIndex is bofore the stream index then reset
            while (logicalIndex > m_StreamIndex) MoveNext();//While the logicalIndex is > the stream index MoveNext (casues m_StreamIndex to be increased).
        }

        internal void SelectStream(ulong absolutePosition)
        {
            if (m_Disposed) return;
            if (TotalPosition == absolutePosition) return;
            else if (absolutePosition < TotalPosition) m_Enumerator.Reset(); //If seeking to a position before the TotalPosition reset
            //While the total postion is not in range
            while (TotalPosition < absolutePosition)
            {
                //Move to the next stream (causing TotalPosition to advance by the current streams length), if we cant then return
                if (!MoveNext()) return;
                //subtract the length of the stream we skipped from the absolutePosition
                if (CurrentStream.Length > 0) absolutePosition -= (ulong)CurrentStream.Length;
            }
        }

        #endregion

        #region Wrappers

        public override int ReadByte()
        {
            return CurrentStream.ReadByte();
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            return CoreRead(buffer, offset, count);
        }

        internal protected int CoreRead(byte[] buffer, long offset, long count, System.IO.SeekOrigin readOrigin = System.IO.SeekOrigin.Current)
        {
            switch (readOrigin)
            {
                case System.IO.SeekOrigin.Begin:
                    {
                        Seek(offset, System.IO.SeekOrigin.Begin);
                        goto case System.IO.SeekOrigin.Current;
                    }
                case System.IO.SeekOrigin.End:
                    {
                        //Seek to the end
                        MoveToEnd();

                        //Use the current case
                        goto case System.IO.SeekOrigin.Current;
                    }
                case System.IO.SeekOrigin.Current:
                    {
                        int read = 0;
                        while (read < count)
                        {
                            if (CurrentStream.Position < offset && CurrentStream.CanSeek) CurrentStream.Seek(offset, System.IO.SeekOrigin.Begin);
                            read += CurrentStream.Read(buffer, (int)offset, (int)count - (int)read);
                            if (CurrentStream.Position >= CurrentStream.Length && read < count) if (!MoveNext()) break;
                            //if (read != -1) m_AbsolutePosition += (uint)read;
                        }
                        return read;
                    }
                default:
                    {
                        Utility.BreakIfAttached();
                        break;
                    }
            }
            return 0;
        }

        bool MoveNext()
        {
            if (m_Disposed || m_Streams == null || m_Enumerator == null) return false;
            //If the current stream can seek it's not a big deal to reset it now also
            //if (m_CurrentStream.CanSeek) m_CurrentStream.Seek(0, System.IO.SeekOrigin.Begin);
            m_AbsolutePosition += (ulong)(m_CurrentStream.Count - m_CurrentStream.Position); //Cumulate the position of the non seeking stream - what was already read
            //Advance the stream index
            ++m_StreamIndex;
            //Return the result of moving the enumerator to the next available streeam
            return m_Enumerator.MoveNext();
        }

        public override long Seek(long offset, System.IO.SeekOrigin origin)
        {
            switch (origin)
            {
                case System.IO.SeekOrigin.End:
                case System.IO.SeekOrigin.Begin:
                    return (long)SeekAbsolute(offset, System.IO.SeekOrigin.Begin);
                case System.IO.SeekOrigin.Current:
                    return m_CurrentStream.Seek(offset, origin);
                default: return m_CurrentStream.Position;
            }
        }

        public void MoveToEnd()
        {
            //While thre is a stream to advance
            while (MoveNext())
            {
                //Move the current stream to it's last position
                CurrentStream.Position = CurrentStream.Length;
            }
        }

        public ulong SeekAbsolute(long offset, System.IO.SeekOrigin origin)
        {
            switch (origin)
            {
                case System.IO.SeekOrigin.Current:
                    {

                        //Determine how many bytes to read in terms of long
                        long offsetPosition = (long)TotalPosition - offset;
                        if (offsetPosition < 0) CurrentStream.Seek(offsetPosition, System.IO.SeekOrigin.Current);
                        else CurrentStream.Position = offsetPosition;
                        return TotalPosition;
                    }
                case System.IO.SeekOrigin.Begin:
                    {
                        SelectStream((ulong)offset);
                        goto case System.IO.SeekOrigin.Current;
                    }
                case System.IO.SeekOrigin.End:
                    {
                        MoveToEnd();
                        goto case System.IO.SeekOrigin.Current;
                    }
                default:
                    {
                        Utility.BreakIfAttached();
                        break;
                    }
            }
            return m_AbsolutePosition;
        }



        IEnumerator<EnumerableByteStream> GetEnumerator() { return m_Disposed ? null : m_Streams.GetEnumerator(); }

        public override void SetLength(long value)
        {
            //If the position is < value set the position to the value first which will update CurrentStream if required.
            if (value < Length) Position = (long)m_AbsolutePosition + value;
            //Set the length of the current stream 
            CurrentStream.SetLength(value);
            m_AbsolutePosition = (ulong)value;
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            if (count < CoreWrite(buffer, (ulong)offset, (ulong)count))
            {
#if DEBUG
                Utility.BreakIfAttached();
#endif
            }
        }

        ///Todo => Test and complete
        internal protected int CoreWrite(byte[] buffer, ulong offset, ulong count, System.IO.SeekOrigin readOrigin = System.IO.SeekOrigin.Current)
        {
            //Select the stream to write based on the offset
            SelectStream((ulong)offset);
            switch (readOrigin)
            {
                case System.IO.SeekOrigin.Current:
                    {
                        return (this as IEnumerator<System.IO.Stream>).Current.Read(buffer, (int)offset, (int)count);
                    }
                case System.IO.SeekOrigin.Begin:
                    {
                        return (this as IEnumerator<System.IO.Stream>).Current.Read(buffer, (int)offset, (int)count);
                    }
                case System.IO.SeekOrigin.End:
                    {
                        return (this as IEnumerator<System.IO.Stream>).Current.Read(buffer, (int)offset, (int)count);
                    }
                default:
                    {
#if DEBUG
                        Utility.BreakIfAttached();
#endif
                        break;
                    }
            }
            return 0;
        }

        IEnumerator<EnumerableByteStream> IEnumerable<EnumerableByteStream>.GetEnumerator()
        {
            return m_Streams.GetEnumerator();
        }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return m_Streams.GetEnumerator();
        }

        EnumerableByteStream IEnumerator<EnumerableByteStream>.Current
        {
            get { return GetEnumerator().Current; }
        }

        void IDisposable.Dispose()
        {
            m_Disposed = true;
            if (m_Streams != null) m_Streams = null;
            m_StreamIndex = -1;
            base.Dispose();
        }

        void System.Collections.IEnumerator.Reset()
        {
            foreach (EnumerableByteStream stream in m_Streams) if (stream.CanSeek) stream.Seek(0, System.IO.SeekOrigin.Begin);
            GetEnumerator().Reset();
        }

        object System.Collections.IEnumerator.Current
        {
            get { return CurrentStream; }
        }

        bool System.Collections.IEnumerator.MoveNext()
        {
            return MoveNext();
        }

        IEnumerator<byte> IEnumerable<byte>.GetEnumerator() { return new EnumerableByteStream(this as IEnumerable<byte>).GetEnumerator(); }

        byte IEnumerator<byte>.Current { get { return (this as IEnumerable<byte>).GetEnumerator().Current; } }

        #endregion
    }

    #endregion

    #endregion