Пример #1
0
        protected void procEndConnect(IAsyncResult ar)
        {
            if (ar == null || ar.AsyncState == null)
            {
                State = eState.Closed;
                return;
            }

            asyncObj ao = (asyncObj)ar.AsyncState;

            try
            {
                innerSocket = ao._socket;
                if (innerSocket.Connected == false)
                {
                    Disconnect();
                    return;
                }
                ao._socket.EndConnect(ar);

                if (innerSocket == null)
                {
                    if (onError != null)
                    {
                        onError(23, "procEndConnect error : InnerSocket=null)");
                    }
                    Disconnect();
                }

                if (this.onConnect != null)
                {
                    this.onConnect(this);
                }
            }
            catch (Exception ex)
            {
                if (onError != null)
                {
                    onError(21, string.Format("procEndConnect error (Ex.Message={0})", ex.Message));
                }
                State = eState.Closed;
                return;
            }

            if (isConnected)
            {
                State = eState.Connected;
                Debug.WriteLine(string.Format("Socket connected to {0}", innerSocket.RemoteEndPoint.ToString()));
                procBeginReceive();
            }
            else
            {
                State = eState.Closed;
            }
        }
Пример #2
0
        private void procEndDisconnect(IAsyncResult ar)
        {
            asyncObj ao = (asyncObj)ar.AsyncState;

            try
            {
                ao._socket.EndDisconnect(ar);
            }
            catch (Exception ex)
            {
                if (onError != null)
                {
                    onError(109, string.Format("procEndDisconnect error (Ex.Message={0})", ex.Message));
                }
                Disconnect();
            }
        }
Пример #3
0
        private void procEndAccept(IAsyncResult ar)
        {
            asyncObj ao = (asyncObj)ar.AsyncState;

            try
            {
                innerSocket = ao._socket.EndAccept(ar);
                State       = eState.Connected;
                if (this.onConnect != null)
                {
                    this.onConnect(this);
                }
                procBeginReceive();
            }
            catch (Exception ex)
            {
                if (onError != null)
                {
                    onError(61, string.Format("procEndAccept error (Ex.Message={0})", ex.Message));
                }
                Disconnect();
            }
        }
Пример #4
0
        protected void procEndReceive(IAsyncResult ar)
        {
            SocketError err = SocketError.SocketError;

            try
            {
                asyncObj ao          = (asyncObj)ar.AsyncState;
                int      bytesToRead = 0;
                err         = SocketError.SocketError;
                bytesToRead = ao._socket.EndReceive(ar, out err);

                if (bytesToRead > 0)
                {
                    byte[] rcvBuff = new byte[bytesToRead];
                    Array.Copy(BUFFER, rcvBuff, bytesToRead);

                    if (this.onDataArrival != null)
                    {
                        this.onDataArrival(this, rcvBuff, bytesToRead);
                    }
                    procBeginReceive();
                }
                else
                {
                    Disconnect();
                }
            }
            catch (Exception ex)
            {
                if (onError != null)
                {
                    onError(41, string.Format("procEndReceive error (Code={0}) (Ex.Message={1})", err.ToString(), ex.Message));
                }
                Disconnect();
            }
        }