C# 使用sharpziplib写的一个可以压缩和解压缩文件夹的类

  /// <summary>
    /// 自定义读取流（只读）
    /// </summary>
    internal  class  CusStreamReader : Stream
    {
        long  _endPosition; //结束位置
        Stream innerStream;
        /// <summary>
        /// 参数为当前流的断点
        /// </summary>
        public  event  Action< long > Reading;

        /// <summary>
        /// 直接使用原始流。
        /// </summary>
        /// <param name="stream">原始流</param>
        public  CusStreamReader(Stream stream)
        {
            this .innerStream = stream;
            _endPosition = stream.Length;
        }
        /// <summary>
        /// 使用流当前位置，指定长度初始化自定义流
        /// </summary>
        /// <param name="stream">原始流</param>
        /// <param name="count">使用长度</param>
        public  CusStreamReader(Stream stream,  long  count)
        {
            this .innerStream = stream;
            _endPosition = stream.Position + count;
            if  (_endPosition > stream.Length)
                _endPosition = stream.Length;
        }
        /// <summary>
        /// 指定初始位置、长度初始化自定义流
        /// </summary>
        /// <param name="stream">原始流</param>
        /// <param name="offset">初始位置</param>
        /// <param name="count">使用长度</param>
        public  CusStreamReader(Stream stream,  long  offset,  long  count)
        {
            stream.Position = offset > stream.Length ? stream.Length : offset;
            this .innerStream = stream;
            _endPosition = offset + count;
            if  (_endPosition > stream.Length)
                _endPosition = stream.Length;
        }
        /// <summary>
        /// 从自定义流读取指定长度到array，但是不超过初始化时设定的长度。
        /// </summary>
        /// <returns>读取的字节数</returns>
        public  override  int  Read( byte [] array,  int  offset,  int  count)
        {
            int  readcount = 0;
            if  (Position + count >  this ._endPosition)
                readcount = innerStream.Read(array, offset, ( int )( this ._endPosition - Position));
            else
                readcount = innerStream.Read(array, offset, count);
            if  (Reading !=  null )
                Reading(Position);
            return  readcount;
        }
        /// <summary>
        /// 从自定义流读取一个字节，但是不超过初始化时设定的长度。
        /// </summary>
        /// <returns>读取的字节，未找到则返回-1</returns>
        public  override  int  ReadByte()
        {
            if  (Position >=  this ._endPosition)
                return  -1;
            else
                return  base .ReadByte();
        }

        public  override  bool  CanRead
        {
            get  {  return  innerStream.CanRead; }
        }

        public  override  bool  CanSeek
        {
            get  {  return  false ; }
        }

        public  override  bool  CanWrite
        {
            get  {  return  false ; }
        }

        public  override  void  Flush()
        {
            throw  new  NotImplementedException();
        }

        /// <summary>
        /// 自定义流剩余长度。
        /// </summary>
        public  override  long  Length
        {
            get  {  return  _endPosition - innerStream.Position; }
        }

        /// <summary>
        /// 自定义流位置，返回原始流的位置
        /// </summary>
        public  override  long  Position
        {
            get
            {
                return  innerStream.Position;
            }
            set
            {
                throw  new  NotImplementedException();
            }
        }

        public  override  long  Seek( long  offset, SeekOrigin origin)
        {
            throw  new  NotImplementedException();
        }

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

        public  override  void  Write( byte [] buffer,  int  offset,  int  count)
        {
            throw  new  NotImplementedException();
        }
    }