封装stream，在读写stream时提供事件通知

欢迎您访问我爱IT技术网，今天小编为你分享的编程技术是：【封装stream，在读写stream时提供事件通知】，下面是详细的分享！

封装stream，在读写stream时提供事件通知

以下为引用的内容：
 public class EventStream : Stream
    {
        public event EventHandler<FStreamDataEventArgs> OnBeforeRead;
        public event EventHandler<FStreamDataEventArgs> OnBeforeWrite;

        private Stream stream;
        public EventStream(Stream stream)
        {
            if (stream==null) throw new ArgumentNullException("EventStream");
            this.stream=stream;
        }

        [====Stream members====]#region [====Stream members====]
        public override bool CanRead
        {
            get { return stream.CanRead; }
        }

        public override bool CanSeek
        {
            get { return stream.CanSeek; }
        }

        public override bool CanWrite
        {
            get { return stream.CanWrite; }
        }

        public override void Flush()
        {
            stream.Flush();
        }

        public override long Length
        {
            get { return stream.Length; }
        }

        public override long Position
        {
            get
            {
                return stream.Position;
            }
            set
            {
                stream.Position=value;
            }
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            int readSize=stream.Read(buffer, offset, count);
            if (OnBeforeRead !=null)
                OnBeforeRead(this, new FStreamDataEventArgs(buffer, offset, readSize));
            return readSize;
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            return stream.Seek(offset, origin);
        }

        public override void SetLength(long value)
        {
            stream.SetLength(value);
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            if (OnBeforeWrite !=null)
                OnBeforeWrite(this, new FStreamDataEventArgs(buffer, offset, count));
            stream.Write(buffer, offset, count);
        }

        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count,
            AsyncCallback callback, object state)
        {
            InternalAsyncState myState=new InternalAsyncState(
                              new FStreamDataEventArgs(buffer, offset, count), state);
            AsyncCallback myCallback=new AsyncCallback(
                              new InternalCallback(OnBeforeRead, callback).Callback);
            return new EventStreamAsyncResult(
                                 stream.BeginRead(buffer, offset, count, myCallback, myState));
        }

        public override int EndRead(IAsyncResult asyncResult)
        {
            EventStreamAsyncResult esar=asyncResult as EventStreamAsyncResult;
            if (esar !=null)
                return stream.EndRead(esar.InternalAsyncResult);
            else
                return stream.EndRead(asyncResult);
        }

        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            InternalAsyncState myState=new InternalAsyncState(
                              new FStreamDataEventArgs(buffer, offset, count), state);
            AsyncCallback myCallback=new AsyncCallback(
                              new InternalCallback(OnBeforeWrite, callback).Callback);
            return new EventStreamAsyncResult(
                              stream.BeginWrite(buffer, offset, count, myCallback, myState));
        }

        public override void EndWrite(IAsyncResult asyncResult)
        {
            stream.EndWrite(asyncResult);
        }

        #endregion

        private class InternalCallback
        {
            private AsyncCallback callback;
            private EventHandler<FStreamDataEventArgs> internalHandler;

            public InternalCallback(EventHandler<FStreamDataEventArgs> internalHandler, AsyncCallback callback)
            {
                this.internalHandler=internalHandler;
                this.callback=callback;
            }

            internal void Callback(IAsyncResult asyncResult)
            {
                InternalAsyncState myState=asyncResult.AsyncState as InternalAsyncState;
                if (internalHandler !=null && myState !=null)
                    internalHandler(this, myState.StreamDataEventArgs);
                callback(new EventStreamAsyncResult(asyncResult));
            }
        }

        private class InternalAsyncState
        {
            object state;
            FStreamDataEventArgs streamDataEventArgs;

            public object State
            {
                get { return state; }
            }

            public FStreamDataEventArgs StreamDataEventArgs
            {
                get { return streamDataEventArgs; }
            }

            public InternalAsyncState(FStreamDataEventArgs streamDataEventArgs, object state)
            {
                this.streamDataEventArgs=streamDataEventArgs;
                this.state=state;
            }
        }

        private class EventStreamAsyncResult : IAsyncResult
        {
            IAsyncResult ar;

            public EventStreamAsyncResult(IAsyncResult ar)
            {
                if (ar==null) throw new ArgumentNullException("EventStreamAsyncResult");
                this.ar=ar;
            }
            IAsyncResult Members#region IAsyncResult Members

            public object AsyncState
            {
                get
                {
                    InternalAsyncState myState=ar.AsyncState as InternalAsyncState;
                    if (myState !=null)
                        return myState.State;
                    else
                        return ar.AsyncState;
                }
            }

            internal IAsyncResult InternalAsyncResult
            {
                get { return ar; }
            }

            public System.Threading.WaitHandle AsyncWaitHandle
            {
                get { return ar.AsyncWaitHandle; }
            }

            public bool CompletedSynchronously
            {
                get { return ar.CompletedSynchronously; }
            }

            public bool IsCompleted
            {
                get { return ar.IsCompleted; }
            }

            #endregion
        }
    }

    public class FStreamDataEventArgs : EventArgs
    {
        private byte[] buffer;
        private int offset;
        private int count;

        public FStreamDataEventArgs(byte[] buffer, int offset, int count)
        {
            if(buffer==null) throw new ArgumentNullException("FStreamDataEventArgs");
            if(offset + count>buffer.Length) throw new ArgumentOutOfRangeException("FStreamDataEventArgs");

            this.buffer=buffer;
            this.offset=offset;
            this.count=count;
        }

        /// <summary>
        /// 数据缓存
        /// </summary>
        public byte[] Buffer
        {
          get { return buffer; }
        }

        /// <summary>
        /// 数据开始位置
        /// </summary>
        public int Offset
        {
          get { return offset; }
        }

        /// <summary>
        /// 数据长度
        /// </summary>
        public int Count
        {
          get { return count; }
        }
    }

以上所分享的是关于封装stream，在读写stream时提供事件通知，下面是编辑为你推荐的有价值的用户互动：

　　相关问题：C#怎样将资源文件读取到stream中？

　　答：MemoryStream ms=new MemoryStream(Properties.Resources.myFile);如果你的myFile是byte[]的话， >>详细

　　相关问题：C# stream 读取数据,stream长度不为0，为什么不能r...

　　答：streamFrom.Position = 0; >>详细

　　相关问题：如何通过streamreader和streamwrite常用方法创建并...

　　答：问题应该是出在StreamReader与StreamWriter不能同时对同一个文件进行操作。 可以边读边替换并保存到一个变量或数组中（感觉用StringBuilder最好），然后关闭StreamReader再打开StreamWriter进行保存。 >>详细