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.BeginRead(buffer, 0, byte2read, new AsyncCallback(EndReadCallback), state);

private void EndReadCallback(IAsyncResult asyncResult)
{
    object state = asyncResult.AsyncState;
    nReadSize = stream.EndRead(asyncResult);
            //
}