public void AcceptAsync()
        {
            var args = new SocketAsyncEventArgs();

            args.Completed += (_, __) =>
            {
                var error = args.GetError();
                if (error == null)
                {
                    this.scheduler.Schedule(() => this.OnAcceptComplete(result: new EventArgsAsyncServerChildTcpSocket(this.scheduler, args.AcceptSocket)));
                }
                else
                {
                    this.scheduler.Schedule(() => this.OnAcceptComplete(ex: error));
                }
            };
        }
        public void ReadAsync(byte[] buffer, int offset, int size)
        {
            this.state.Read();
            var args = new SocketAsyncEventArgs();

            args.SetBuffer(buffer, offset, size);
            args.Completed += (_, __) =>
            {
                var error = args.GetError();
                if (error == null)
                {
                    var result = args.BytesTransferred;
                    this.scheduler.Schedule(() => this.OnReadComplete(result: result));
                }
                else
                {
                    this.scheduler.Schedule(() => this.OnReadComplete(ex: error));
                }
            };
        }
        public void ConnectAsync(EndPoint server)
        {
            var args = new SocketAsyncEventArgs {
                RemoteEndPoint = server
            };

            args.Completed += (_, __) =>
            {
                var error = args.GetError();
                if (error == null)
                {
                    this.scheduler.Schedule(() => this.OnConnectComplete());
                }
                else
                {
                    this.scheduler.Schedule(() => this.OnConnectComplete(error));
                }
            };
            this.socket.ConnectAsync(args);
        }
        public void ReadAsync(IList <ArraySegment <byte> > buffers)
        {
            this.state.Read();
            var args = new SocketAsyncEventArgs {
                BufferList = buffers
            };

            args.Completed += (_, __) =>
            {
                var error = args.GetError();
                if (error == null)
                {
                    var result = args.BytesTransferred;
                    this.scheduler.Schedule(() => this.OnReadComplete(result: result));
                }
                else
                {
                    this.scheduler.Schedule(() => this.OnReadComplete(ex: error));
                }
            };
        }
示例#5
0
        public void ShutdownAsync()
        {
            this.state.Close();
            this.ReadCompleted  = null;
            this.WriteCompleted = null;
            var args = new SocketAsyncEventArgs();

            args.Completed += (_, __) =>
            {
                var error = args.GetError();
                if (error == null)
                {
                    this.scheduler.Schedule(() => this.OnShutdownComplete());
                }
                else
                {
                    this.scheduler.Schedule(() => this.OnShutdownComplete(error));
                }
            };
            this.socket.DisconnectAsync(args);
        }
        private void Write(IList <ArraySegment <byte> > buffers, object state)
        {
            var args = new SocketAsyncEventArgs {
                BufferList = buffers, UserToken = state
            };

            args.Completed += (_, __) =>
            {
                var error = args.GetError();
                if (error == null)
                {
                    var result           = args.BytesTransferred;
                    var remainingBuffers = SocketHelpers.RemainingBuffers(buffers, result);
                    if (remainingBuffers.Count != 0)
                    {
                        this.scheduler.Schedule(
                            () =>
                        {
                            try
                            {
                                this.Write(remainingBuffers, state);
                            }
                            catch (Exception ex)
                            {
                                this.OnWriteComplete(state, ex);
                            }
                        });
                    }
                    else
                    {
                        this.scheduler.Schedule(() => this.OnWriteComplete(state));
                    }
                }
                else
                {
                    this.scheduler.Schedule(() => this.OnWriteComplete(state, error));
                }
            };
            this.socket.SendAsync(args);
        }
        private void Write(byte[] buffer, int offset, int size, object state)
        {
            var args = new SocketAsyncEventArgs {
                UserToken = state
            };

            args.SetBuffer(buffer, offset, size);
            args.Completed += (_, __) =>
            {
                var error = args.GetError();
                if (error == null)
                {
                    var result = args.BytesTransferred;
                    if (result < size)
                    {
                        this.scheduler.Schedule(
                            () =>
                        {
                            try
                            {
                                this.Write(buffer, offset + result, size - result, state);
                            }
                            catch (Exception ex)
                            {
                                this.OnWriteComplete(state, ex);
                            }
                        });
                    }
                    else
                    {
                        this.scheduler.Schedule(() => this.OnWriteComplete(state));
                    }
                }
                else
                {
                    this.scheduler.Schedule(() => this.OnWriteComplete(state, error));
                }
            };
            this.socket.SendAsync(args);
        }