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);
            //
}