예제 #1
0
        public void Initialize()
        {
            _asyncUserToken = new AsyncUserToken();
            _asyncUserToken.ReceiveSocketAsyncEventArgs.SetBuffer(new byte[BUFFER_SIZE], 0, BUFFER_SIZE);
            _asyncUserToken.ReceiveSocketAsyncEventArgs.Completed += IO_Completed;
            _asyncUserToken.SendSocketAsyncEventArgs.SetBuffer(new byte[BUFFER_SIZE], 0, 0);
            _asyncUserToken.SendSocketAsyncEventArgs.Completed += IO_Completed;

            var      remoteIP      = IPAddress.Parse(_remoteServerIP);
            var      remotePort    = int.Parse(_remoteServerPort);
            EndPoint remotEndPoint = new IPEndPoint(remoteIP, remotePort);

            _asyncUserToken.ReceiveSocketAsyncEventArgs.RemoteEndPoint = remotEndPoint;
            _asyncUserToken.SendSocketAsyncEventArgs.RemoteEndPoint    = remotEndPoint;
        }
예제 #2
0
        private void CloseClientSocket(AsyncUserToken asyncUserToken)
        {
            string clientIP = string.Empty;

            try
            {
                if (asyncUserToken.Socket != null)
                {
                    clientIP = asyncUserToken.Socket.RemoteEndPoint.ToString();
                    asyncUserToken.Socket.Shutdown(SocketShutdown.Both);
                    asyncUserToken.Socket.Close();
                    asyncUserToken.Socket = null;
                    asyncUserToken.ReceiveSocketAsyncEventArgs.AcceptSocket = null;
                    asyncUserToken.SendSocketAsyncEventArgs.AcceptSocket    = null;
                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("AsyncServerBase->CloseClientSocket出现异常{0}, clientIP = {1}", ex, clientIP);
            }

            asyncUserToken.Reset();
        }
예제 #3
0
        private AsyncUserToken GetAsyncUserToken(Socket clientSocket)
        {
            AsyncUserToken userToken = null;

            if (_asyncUserTokenPool.Count == 0)
            {
                userToken = new AsyncUserToken()
                {
                    Socket = clientSocket
                };

                userToken.ReceiveSocketAsyncEventArgs.SetBuffer(new byte[BUFFER_SIZE], 0, BUFFER_SIZE);
                userToken.ReceiveSocketAsyncEventArgs.AcceptSocket = clientSocket;
                userToken.ReceiveSocketAsyncEventArgs.Completed   += IO_Completed;
                _asyncUserTokenPool.Add(userToken);
            }
            else
            {
                userToken = _asyncUserTokenPool[0];
            }

            return(userToken);
        }
예제 #4
0
        private void ProcessReceive(SocketAsyncEventArgs readEventArgs)
        {
            /*需要检查客户端是否关闭了连接*/
            AsyncUserToken asyncUserToken = readEventArgs.UserToken as AsyncUserToken;

            try
            {
                if (readEventArgs.BytesTransferred > 0 && readEventArgs.SocketError == SocketError.Success)
                {
                    Interlocked.Add(ref _totalBytesReceived, (long)readEventArgs.BytesTransferred);
                    _log.Info(string.Format("目前已接受{0}字节的数据", _totalBytesReceived));

                    /*读取缓冲区中的数据*/
                    /*半包, 粘包*/
                    try
                    {
                        /*读取数据*/
                        byte[] dataTransfered = new byte[readEventArgs.BytesTransferred];
                        Array.Copy(readEventArgs.Buffer, readEventArgs.Offset, dataTransfered, 0, readEventArgs.BytesTransferred);
                        asyncUserToken.ReceiveBuffer.AddRange(dataTransfered);

                        /* 4字节包头(长度) + 包体*/
                        /* Header + Body */

                        /* 接收到的数据可能小于一个包的大小,需分多次接收
                         * 先判断包头的大小,够一个完整的包再处理
                         */

                        while (asyncUserToken.ReceiveBuffer.Count > DATA_CHUNK_LENGTH_HEADER)
                        {
                            /*判断包的长度*/
                            byte[] lenBytes = asyncUserToken.ReceiveBuffer.GetRange(0, DATA_CHUNK_LENGTH_HEADER).ToArray();
                            int    bodyLen  = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(lenBytes, 0));               //包体的长度

                            var packageLength = DATA_CHUNK_LENGTH_HEADER + bodyLen;                                          //一个数据包的长度,4字节包头 + 包体的长度
                            var receivedLengthExcludeHeader = asyncUserToken.ReceiveBuffer.Count - DATA_CHUNK_LENGTH_HEADER; //去掉包头之后接收的长度

                            /*接收的数据长度不够时,退出循环,让程序继续接收*/
                            if (receivedLengthExcludeHeader < bodyLen)
                            {
                                break;
                            }

                            /*接收的数据长度大于一个包的长度时,则提取出来,交给后面的程序去处理*/
                            byte[] receivedBytes = asyncUserToken.ReceiveBuffer.GetRange(DATA_CHUNK_LENGTH_HEADER, bodyLen).ToArray();
                            asyncUserToken.ReceiveBuffer.RemoveRange(0, packageLength); /*从缓冲区重移出取出的数据*/

                            /*抽象数据处理方法,receivedBytes是一个完整的包*/
                            ProcessData(asyncUserToken, receivedBytes);
                        }

                        /*继续接收, 非常关键的一步*/
                        if (asyncUserToken.Socket != null && !asyncUserToken.Socket.ReceiveAsync(readEventArgs))
                        {
                            ProcessReceive(readEventArgs);
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Program->ProcessReceive出现异常, Exception = {0}", ex);
                    }
                }
                else
                {
                    CloseClientSocket(asyncUserToken);
                }
            }
            finally
            {
            }
        }