public void Accept(IOArgs args = null)
        {
            if (Disposed)
            {
                throw new ObjectDisposedException("");
            }

            IOArgs acceptArgs = args = args == null?IOArgs.Alloc() : args;

            acceptArgs.Handler = this;

            try
            {
                if (!_socket.AcceptAsync(acceptArgs))
                {
                    SubmitIO(acceptArgs);
                }
            }
            catch (Exception ex)
            {
                if (args == null)
                {
                    acceptArgs.Dispose();
                }

                throw ex;
            }
        }
        public override void OnIO(IOArgs args)
        {
            switch (args.LastOperation)
            {
            case SocketAsyncOperation.Accept:
                OnAccept(args);
                break;

            case SocketAsyncOperation.Connect:
                OnConnect(args);
                break;

            case SocketAsyncOperation.Disconnect:
                OnDisconnect(args);
                break;

            case SocketAsyncOperation.Receive:
                OnReceive(args);
                break;

            case SocketAsyncOperation.Send:
                OnSend(args);
                break;
            }
        }
        public void SendArgs(IOArgs args)
        {
            args.Handler = this;

            if (!_socket.SendAsync(args))
            {
                SubmitIO(args);
            }
        }
        public void ReceiveArgs(IOArgs args)
        {
            args.Handler = this;

            if (!_socket.ReceiveAsync(args))
            {
                SubmitIO(args);
            }
        }
        public void Send(string str)
        {
            IOArgs args = IOArgs.Alloc();

            args.SetBuffer(str);

            try
            {
                if (!_socket.SendAsync(args))
                {
                    SubmitIO(args);
                }
            }
            catch (Exception ex)
            {
                args.Dispose();

                throw ex;
            }
        }
        protected override void OnAccept(IOArgs args)
        {
            EchoConnection connection = new EchoConnection(args.AcceptSocket);

            try
            {
                IOArgs receiveArgs = IOArgs.Alloc(); //Allocate args

                connection.DoReceive(receiveArgs);
            }
            catch (Exception)
            {
                connection.Dispose();
            }

            //AcceptSocket, must be null/non connected socket.
            args.AcceptSocket = null;

            Accept(args);
        }
 protected virtual void OnAccept(IOArgs args)
 {
 }
 public override void OnIOException(IOArgs args, Exception ex)
 {
     args.Dispose();
     Dispose();
 }