void dataRead(IAsyncResult result)
        {
            byte[] buffer = result.AsyncState as byte[];

            string data = ASCIIEncoding.ASCII.GetString(buffer, 0, buffer.Length);

            TransmitedDataType datatype = TransmitedDataType.Unknown;

            data = data.TrimEnd();

            if (data.Length > 4 && data.StartsWith("C"))
            {
                datatype = data.StartsWith("C101") ? TransmitedDataType.Message : data.StartsWith("C102") ?
                           TransmitedDataType.Status : data.StartsWith("C103") ? TransmitedDataType.Command :
                           data.StartsWith("C104") ? TransmitedDataType.Headers : data.StartsWith("C105") ? TransmitedDataType.RawData : TransmitedDataType.Unknown;
                if (datatype == TransmitedDataType.Status)
                {
                    var stateID = Enum.Parse(typeof(NetworkStates), data.Substring(4));

                    if (stateID is NetworkStates)
                    {
                        ServerState = (NetworkStates)stateID;
                        if (ServerState == NetworkStates.Disconnected)
                        {
                            StopReceiving();
                            State       = NetworkStates.Disconnected;
                            ServerState = NetworkStates.Disconnected;
                            connected   = false;
                            client.Close();
                            if (OnServerDisconnected != null)
                            {
                                OnServerDisconnected.Invoke();
                            }
                        }
                        // return;
                    }
                }
                if (datatype != TransmitedDataType.Unknown)
                {
                    data = data.Substring(4);
                }
            }
            latestReceivedData = data;

            if (OnDataReceived != null)
            {
                OnDataReceived.Invoke(data, datatype);
            }

            if (!stopReceiver)
            {
                buffer = new byte[BufferSize];
                connectionStream.BeginRead(buffer, 0, BufferSize, dataRead, buffer);
            }
        }
 public void ReadElementAsync()
 {
     try
     {
         var buffer = new byte[1024];
         stream.BeginRead(buffer, 0, buffer.Length, ReadCallback, buffer);
     }
     catch (Exception ex)
     {
         OnError(this, ex);
     }
 }
示例#3
0
        public IAsyncResult BeginRead(System.IO.Stream stream, AsyncCallback callback, object state)
        {
            _forceNewRead = false;
            if (_offset == _available)
            {
                _offset    = 0;
                _available = 0;
            }
            else if (_buffer.Length - _available < _bufferSize)
            {
                if (_buffer.Length - (_available - _offset) < _bufferSize)
                {
                    var buffer = new byte[_buffer.Length * 2];
                    Array.Copy(_buffer, _offset, buffer, 0, _available - _offset);
                    _buffer = buffer;
                }
                else
                {
                    Array.Copy(_buffer, _offset, _buffer, 0, _available - _offset);
                }
                _available -= _offset;
                _offset     = 0;
            }
            int bufferAvailable = Math.Min(_buffer.Length - _available, _bufferSize);

            return(stream.BeginRead(_buffer, _available, bufferAvailable, callback, state));
        }
        void TransparentStreamReadRequestMessageReceived(TransparentStreamMessageBase transparentStreamMessageBase)
        {
            TransparentStreamReadRequestMessage request = (TransparentStreamReadRequestMessage)transparentStreamMessageBase;

            byte[] buffer = new byte[request.Count];
            try {
                baseStream.BeginRead(buffer, 0, request.Count, (ar) => {
                    try {
                        int bytesRead = baseStream.EndRead(ar);
                        if (bytesRead != ((byte[])ar.AsyncState).Length)
                        {
                            byte[] newBuffer = new byte[bytesRead];
                            System.Buffer.BlockCopy((byte[])ar.AsyncState, 0, newBuffer, 0, bytesRead);
                            objectBusSession.SendMessage(new TransparentStreamReadResponseMessage(streamID, request.ID, newBuffer, null));
                        }
                        else
                        {
                            objectBusSession.SendMessage(new TransparentStreamReadResponseMessage(streamID, request.ID, (byte[])ar.AsyncState, null));
                        }
                    } catch (Exception ex) {
                        objectBusSession.SendMessage(new TransparentStreamReadResponseMessage(streamID, request.ID, (byte[])ar.AsyncState, ex));
                    }
                }, buffer);
            } catch (Exception ex) {
                objectBusSession.SendMessage(new TransparentStreamReadResponseMessage(streamID, request.ID, null, ex));
            }
        }
示例#5
0
        private void CheckRead()
        {
            if (_stream == null)
            {
                return;
            }

            if (_async != null)
            {
                if (_async.IsCompleted)
                {
                    _readCount  = _stream.EndRead(_async);
                    _readOffset = 0;
                    //Debug.Log("EndRead {0}", _readCount);
                    _async = null;

                    if (_readCount > 0)
                    {
                        LastTime = System.DateTime.Now;
                    }
                }
            }
            else if (Available == 0)
            {
                //Debug.Log("BeginRead");
                _async = _stream.BeginRead(_readBuffer, 0, _readBuffer.Length, null, null);
            }
        }
示例#6
0
        void Reader()
        {
            try
            {
                readAsyncResult = networkStream.BeginRead(readBuffer, 0, 6, new AsyncCallback((asyncResult) =>
                {
                    if (readAsyncResult != asyncResult)
                    {
                        return;
                    }

                    lock (sentLock)
                    {
                        try
                        {
                            var bytesRead = networkStream.EndRead(asyncResult);

                            if (bytesRead > 0)
                            {
                                //We now expect apple to close the connection on us anyway, so let's try and close things
                                // up here as well to get a head start
                                //Hopefully this way we have less messages written to the stream that we have to requeue
                                try { stream.Close(); } catch { }
                                try { stream.Dispose(); } catch { }

                                try { client.Client.Shutdown(SocketShutdown.Both); } catch { }
                                try { client.Client.Dispose(); } catch { }

                                try { client.Close(); } catch { }

                                client = null;
                                stream = null;

                                //Get the enhanced format response
                                // byte 0 is always '1', byte 1 is the status, bytes 2,3,4,5 are the identifier of the notification
                                var status     = readBuffer[1];
                                var identifier = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(readBuffer, 2));

                                HandleFailedNotification(identifier, status);

                                //Start reading again
                                Reader();
                            }
                            else
                            {
                                connected = false;
                            }
                        }
                        catch
                        {
                            connected = false;
                        }
                    }                     // End Lock
                }), null);
            }
            catch
            {
                connected = false;
            }
        }
示例#7
0
        public void downloading(IAsyncResult res)
        {
            int read = 0;

            try { read = response_stream.EndRead(res); }
            catch (Exception e) { failure("Error receving response from server after saving file", e); return; }
            if (read > 0)
            {
                downloaded += read;
                if (downloaded < buffer.Length)
                {
                    try { response_stream.BeginRead(buffer, downloaded, buffer.Length - downloaded, downloading, this); }
                    catch (Exception e) { failure("Error receving response from server after saving file", e); }
                    return;
                }
            }
            try
            {
                response_stream.Close();
                response_stream = null;
            }
            catch (Exception) { }

            string resp = System.Text.Encoding.UTF8.GetString(buffer, 0, downloaded);

            if (resp.Equals("OK"))
            {
                saved = true;
            }
            else
            {
                failure("Error saving file: " + resp, null);
            }
        }
示例#8
0
            static void StreamReadCallback(IAsyncResult ar)
            {
                var This = (GetResponse)ar.AsyncState;

                System.IO.Stream stream = null;
                try
                {
                    stream = This.resp.GetResponseStream();
                    var szRead = stream.EndRead(ar);
                    if (szRead > 0)
                    {
                        This.outputStream.Write(This.temp, 0, szRead);
                        stream.BeginRead(This.temp, 0, This.temp.Length, StreamReadCallback, This);
                    }
                    else
                    {
                        This.SetResponded(This.resp.StatusCode, This.resp.StatusDescription, This.resp.Cookies, This.resp.Headers);
                        stream.Close();
                        stream.Dispose();
                        stream = null;
                        This.resp.Close();
                        This.resp = null;
                    }
                }
                catch (System.Exception e)
                {
                    if (stream != null)
                    {
                        stream.Close();
                        stream.Dispose();
                        stream = null;
                    }
                    This.SetRespondedWithClientError(e);
                }
            }
示例#9
0
        static int _m_BeginRead(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


                System.IO.Stream gen_to_be_invoked = (System.IO.Stream)translator.FastGetCSObj(L, 1);



                {
                    byte[] _buffer = LuaAPI.lua_tobytes(L, 2);
                    int    _offset = LuaAPI.xlua_tointeger(L, 3);
                    int    _count  = LuaAPI.xlua_tointeger(L, 4);
                    System.AsyncCallback _callback = translator.GetDelegate <System.AsyncCallback>(L, 5);
                    object _state = translator.GetObject(L, 6, typeof(object));

                    System.IAsyncResult gen_ret = gen_to_be_invoked.BeginRead(
                        _buffer,
                        _offset,
                        _count,
                        _callback,
                        _state);
                    translator.PushAny(L, gen_ret);



                    return(1);
                }
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
        }
示例#10
0
        void Reader()
        {
            try
            {
                networkStream.BeginRead(readBuffer, 0, 6, new AsyncCallback((asyncResult) =>
                {
                    lock (sentLock)
                    {
                        try
                        {
                            var bytesRead = networkStream.EndRead(asyncResult);

                            if (bytesRead > 0)
                            {
                                Log.Info("in Reader bytes read {0}", bytesRead);
                                //We now expect apple to close the connection on us anyway, so let's try and close things
                                // up here as well to get a head start
                                //Hopefully this way we have less messages written to the stream that we have to requeue
                                try { stream.Close(); stream.Dispose(); }
                                catch { }

                                try { client.Close(); stream.Dispose(); }
                                catch { }

                                //Get the enhanced format response
                                // byte 0 is always '1', byte 1 is the status, bytes 2,3,4,5 are the identifier of the notification
                                var status     = readBuffer[1];
                                var identifier = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(readBuffer, 2));

                                HandleFailedNotification(identifier, status);

                                //Start reading again
                                Reader();
                                //connected = false;
                            }
                            else
                            {
                                Log.Warning("Read 0 bytes, perhaps this is the signal to close the stream. Shutting down client and the bunch.");
                                try { stream.Close(); stream.Dispose(); }
                                catch { }

                                try { client.Close(); stream.Dispose(); }
                                catch { }

                                connected = false;
                            }
                        }
                        catch
                        {
                            connected = false;
                        }
                    }                     // End Lock
                }), null);
            }
            catch
            {
                connected = false;
            }
        }
示例#11
0
 public void startReceive(IAsyncResult res)
 {
     try
     {
         response        = (HttpWebResponse)request.EndGetResponse(res);
         response_stream = response.GetResponseStream();
         response_stream.BeginRead(buffer, 0, buffer.Length, downloading, this);
     }
     catch (Exception e)
     {
         failure("Error receiving response from server after upload", e);
     }
 }
示例#12
0
文件: DNS.cs 项目: hy2013/UnityUtils
            void GetResponseCallback(IAsyncResult asyncResult)
            {
                try
                {
                    WebResponse = WebRequest.EndGetResponse(asyncResult);
                    Stream      = WebResponse.GetResponseStream();

                    BufferOffset = 0;
                    Stream.BeginRead(Buffer, BufferOffset, Buffer.Length, ReadCallback, null);
                }
                catch (System.Exception e)
                {
                    Exception = e;
                }
            }
示例#13
0
 public void startReceive(IAsyncResult res)
 {
     try
     {
         download_response = (HttpWebResponse)download_request.EndGetResponse(res);
         total             = (int)download_response.ContentLength;
         downloaded        = 0;
         onprogress(null, 0, total, 0);
         stream = download_response.GetResponseStream();
         stream.BeginRead(buffer, 0, 65536, downloading, this);
     }
     catch (Exception e)
     {
         failure("Error " + action, e);
     }
 }
示例#14
0
        void Reader()
        {
            try
            {
                var result = networkStream.BeginRead(readBuffer, 0, 6, new AsyncCallback((asyncResult) =>
                {
                    lock (sentLock)
                    {
                        try
                        {
                            var bytesRead = networkStream.EndRead(asyncResult);

                            if (bytesRead > 0)
                            {
                                disconnect();

                                //Get the enhanced format response
                                // byte 0 is always '1', byte 1 is the status, bytes 2,3,4,5 are the identifier of the notification
                                var status     = readBuffer[1];
                                var identifier = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(readBuffer, 2));

                                HandleFailedNotification(identifier, status);

                                //Start reading again
                                Reader();
                            }
                            else
                            {
                                connected = false;
                            }
                        }
                        catch
                        {
                            connected = false;
                        }
                    }                     // End Lock
                }), null);
            }
            catch
            {
                connected = false;
            }
        }
示例#15
0
文件: DNS.cs 项目: hy2013/UnityUtils
            void ReadCallback(IAsyncResult asyncResult)
            {
                try
                {
                    var size = Stream.EndRead(asyncResult);
                    if (size <= 0)
                    {
                        var ip = System.Text.Encoding.ASCII.GetString(Buffer);
                        IPAddress = IPAddress.Parse(ip);
                        return;
                    }

                    BufferOffset += size;
                    Stream.BeginRead(Buffer, BufferOffset, Buffer.Length - BufferOffset, ReadCallback, null);
                }
                catch (System.Exception e)
                {
                    Exception = e;
                }
            }
示例#16
0
        public void downloading(IAsyncResult res)
        {
            int read;

            try { read = stream.EndRead(res); }
            catch (Exception e) { failure("Error " + action, e); return; }
            if (read > 0)
            {
                downloaded += read;
                onprogress(buffer, read, total, downloaded);
                try { stream.BeginRead(buffer, 0, 65536, downloading, this); }
                catch (Exception e) { failure("Error " + action, e); }
                return;
            }
            try
            {
                stream.Close(); stream = null;
            }
            catch (Exception) { }
            onsuccess();
        }
示例#17
0
        void Reader()
        {
            try
            {
                var result = networkStream.BeginRead(readBuffer, 0, 6, new AsyncCallback((asyncResult) =>
                {
                    lock (sentLock)
                    {
                        try
                        {
                            var bytesRead = networkStream.EndRead(asyncResult);

                            if (bytesRead > 0)
                            {
                                //We now expect apple to close the connection on us anyway, so let's try and close things
                                // up here as well to get a head start
                                //Hopefully this way we have less messages written to the stream that we have to requeue
                                try { stream.Close(); stream.Dispose(); }
                                catch { }

                                try { client.Close(); stream.Dispose(); }
                                catch { }

                                //Get the enhanced format response
                                // byte 0 is always '1', byte 1 is the status, bytes 2,3,4,5 are the identifier of the notification
                                var status     = readBuffer[1];
                                var identifier = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(readBuffer, 2));

                                int failedNotificationIndex         = -1;
                                SentNotification failedNotification = null;

                                //Try and find the failed notification in our sent list
                                for (int i = 0; i < sentNotifications.Count; i++)
                                {
                                    var n = sentNotifications[i];

                                    if (n.Identifier.Equals(identifier))
                                    {
                                        failedNotificationIndex = i;
                                        failedNotification      = n;
                                        break;
                                    }
                                }

                                //Don't bother doing anything unless we know what failed
                                if (failedNotification != null && failedNotificationIndex > -1)
                                {
                                    //Anything before the failed message must have sent OK
                                    // so let's expedite the success status Success for all those before the failed one
                                    if (failedNotificationIndex > 0)
                                    {
                                        for (int i = 0; i < failedNotificationIndex; i++)
                                        {
                                            this.Events.RaiseNotificationSent(sentNotifications[i].Notification);
                                        }
                                    }

                                    //The notification that failed needs to have a failure event raised
                                    // we don't requeue it because apple told us it failed for real
                                    this.Events.RaiseNotificationSendFailure(failedNotification.Notification,
                                                                             new NotificationFailureException(status, failedNotification.Notification));

                                    // finally, raise failure for anything after the index of this failed one
                                    // in the sent list, since we may have sent them but apple will have disregarded
                                    // anything after the failed one and not told us about it
                                    if (failedNotificationIndex < sentNotifications.Count - 1)
                                    {
                                        //Requeue the failed notification since we're not sure it's a bad
                                        // notification, just that it was sent after a bad one was
                                        for (int i = failedNotificationIndex + 1; i <= sentNotifications.Count - 1; i++)
                                        {
                                            this.QueueNotification(sentNotifications[i].Notification, false);
                                        }
                                    }

                                    //Now clear out the sent list since we processed them all manually above
                                    sentNotifications.Clear();
                                }

                                //Start reading again
                                Reader();
                            }
                            else
                            {
                                connected = false;
                            }
                        }
                        catch
                        {
                            connected = false;
                        }
                    }                     // End Lock
                }), null);
            }
            catch
            {
                connected = false;
            }
        }
示例#18
0
 public override void recv(byte[] buffer, int offset, int size,
                           ResultHandler rh)
 {
     mStream.BeginRead(buffer, offset, size, new AsyncCallback(RecvCallback), rh);
 }
示例#19
0
文件: DNS.cs 项目: dpull/UnityUtils
            void GetResponseCallback(IAsyncResult asyncResult)
            {
                try
                {
                    WebResponse = WebRequest.EndGetResponse(asyncResult);
                    Stream = WebResponse.GetResponseStream();

                    BufferOffset = 0;
                    Stream.BeginRead(Buffer, BufferOffset, Buffer.Length, ReadCallback, null);
                }
                catch(System.Exception e)
                {
                    Exception = e;
                }
            }
示例#20
0
 /// <summary>
 /// Transfers an entire source stream to a target
 /// </summary>
 /// <param name="source">
 /// The stream to read
 /// </param>
 /// <param name="target">
 /// The stream to write
 /// </param>
 /// <returns>
 /// The total number of bytes transferred
 /// </returns>
 public Int32 Copy(Stream source, Stream target)
 {
     var copied = 0;
      var bufferIdx = 0;
      // start an initial dummy write to avoid
      // a null test within the copy loop
      var writer = target.BeginWrite(this.buffers[1], 0, 0, null, null);
      for (; ; )
      {
     // read into the current buffer
     var buffer = this.buffers[bufferIdx];
     var reader = source.BeginRead(buffer, 0, buffer.Length, null, null);
     // complete the previous write and the current read
     target.EndWrite(writer);
     var read = source.EndRead(reader);
     if (read == 0)
        break;
     copied += read;
     // start the next write for the completed read
     writer = target.BeginWrite(buffer, 0, read, null, null);
     // swap the buffer index for the next read
     bufferIdx = (bufferIdx + 1) % 2;
      }
      return copied;
 }
        public void Load(SafeUri uri)
        {
            if (is_disposed)
                return;

            //First, send a thumbnail if we have one
            if ((thumb = XdgThumbnailSpec.LoadThumbnail (uri, ThumbnailSize.Large, null)) != null) {
                pixbuf_orientation = ImageOrientation.TopLeft;
                EventHandler<AreaPreparedEventArgs> prep = AreaPrepared;
                if (prep != null)
                    prep (this, new AreaPreparedEventArgs (true));
                EventHandler<AreaUpdatedEventArgs> upd = AreaUpdated;
                if (upd != null)
                    upd (this, new AreaUpdatedEventArgs (new Rectangle (0, 0, thumb.Width, thumb.Height)));
            }

            using (var image_file = ImageFile.Create (uri)) {
                image_stream = image_file.PixbufStream ();
                pixbuf_orientation = image_file.Orientation;
            }

            loading = true;
            // The ThreadPool.QueueUserWorkItem hack is there cause, as the bytes to read are present in the stream,
            // the Read is CompletedAsynchronously, blocking the mainloop
            image_stream.BeginRead (buffer, 0, count, delegate (IAsyncResult r) {
                ThreadPool.QueueUserWorkItem (delegate {HandleReadDone (r);});
            }, null);
        }
示例#22
0
        private void RunningLoop()
        {
            byte[] buffer   = new byte[20];
            int    received = 0;

            while (running)
            {
                while (running)
                {
                    try
                    {
                        ns.BeginRead(buffer, 0, 20, AsyncReceiveCallback, this);
                        //received = ns.Read(buffer, 0, 20);
                    }
                    catch (Exception e)
                    {
                        //Console.WriteLine(e.ToString());
                        continue;
                    }

                    if (received > 0)
                    {
                        //System.Diagnostics.Trace.WriteLine(BitConverter.ToString(buffer));
                        //this.Invoke(setRcvText, BitConverter.ToString(buffer));
                        if (buffer[0] == 0x01)
                        {
                            string text = System.Text.Encoding.UTF8.GetString(buffer, 2, buffer.Length - 2) + " id:" + buffer[1] + " connected";
                            this.Invoke(setLabelStatus, new object[] { text, Color.Lime });
                        }
                        //string command = "";

                        //Keys keycode = (Keys)BitConverter.ToInt16(buffer, 0);

                        //switch(keycode)
                        //{
                        //	case Keys.Up:
                        //		command = "{UP}";
                        //		break;
                        //	case Keys.Down:
                        //		command = "{DOWN}";
                        //		break;
                        //	case Keys.Left:
                        //		command = "{LEFT}";
                        //		break;
                        //	case Keys.Right:
                        //		command = "{RIGHT}";
                        //		break;
                        //	case Keys.Enter:
                        //		command = "{ENTER}";
                        //		break;
                        //System.Diagnostics.Trace.WriteLine(@"SendWait(""" + command + @""")");
                        //System.Windows.Forms.SendKeys.SendWait(command);
                    }
                    else
                    {
                        Console.WriteLine("connection lost");
                        running = false;
                        break;
                    }
                }

                try
                {
                    bc.Close();
                    Console.WriteLine("closed");
                    running = false;
                    break;
                }
                catch
                {
                    running = false;
                    break;
                }
            }
        }
 public void Read(System.IO.Stream stream)
 {
     stream.BeginRead(buffer, 0, buffer.Length, this.DoRead, null);
 }
示例#24
0
        void HandleReadDone(IAsyncResult ar)
        {
            if (is_disposed)
            {
                return;
            }

            int byte_read = image_stream.EndRead(ar);

            lock (sync_handle) {
                if (byte_read == 0)
                {
                    image_stream.Close();
                    Close();
                    Loading          = false;
                    notify_completed = true;
                }
                else
                {
                    try {
                        if (!is_disposed && Write(buffer, (ulong)byte_read))
                        {
                            image_stream.BeginRead(buffer, 0, count, HandleReadDone, null);
                        }
                    } catch (ObjectDisposedException) {
                    } catch (GLib.GException) {
                    }
                }
            }

            GLib.Idle.Add(delegate {
                //Send the AreaPrepared event
                if (notify_prepared)
                {
                    notify_prepared = false;
                    if (thumb != null)
                    {
                        thumb.Dispose();
                        thumb = null;
                    }

                    AreaPrepared?.Invoke(this, new AreaPreparedEventArgs(false));
                }

                //Send the AreaUpdated events
                if (damage != Rectangle.Zero)
                {
                    AreaUpdated?.Invoke(this, new AreaUpdatedEventArgs(damage));
                    damage = Rectangle.Zero;
                }

                //Send the Completed event
                if (notify_completed)
                {
                    notify_completed = false;
                    OnCompleted();
                }

                return(false);
            });
        }
示例#25
0
 public ReadTransaction(System.IO.Stream s, byte[] dest, int off, int len)
     : base(true, new System.AsyncCallback((iar) => s.BeginRead(dest, off, len, new System.AsyncCallback((ia) => s.EndRead(ia)), null)), null, null)
 {
 }
 public void startReceive(IAsyncResult res)
 {
     try
     {
         response = (HttpWebResponse)request.EndGetResponse(res);
         response_stream = response.GetResponseStream();
         response_stream.BeginRead(buffer, 0, buffer.Length, downloading, this);
     }
     catch (Exception e)
     {
         failure("Error receiving response from server after upload", e);
     }
 }
 public void startReceive(IAsyncResult res)
 {
     try
     {
         download_response = (HttpWebResponse)download_request.EndGetResponse(res);
         total = (int)download_response.ContentLength;
         downloaded = 0;
         onprogress(null, 0, total, 0);
         stream = download_response.GetResponseStream();
         stream.BeginRead(buffer, 0, 65536, downloading, this);
     }
     catch (Exception e)
     {
         failure("Error " + action, e);
     }
 }
示例#28
0
 /// <inheritdoc/>
 public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
 {
     return(_underlyingStream.BeginRead(buffer, offset, count, callback, state));
 }