Beispiel #1
0
 /// <summary>
 /// 数据处理中心
 /// </summary>
 /// <param name="receive"></param>
 /// <param name="protocol"></param>
 /// <param name="customer"></param>
 /// <param name="content"></param>
 internal override void DataProcessingCenter(AsyncStateOne receive, int protocol, int customer, byte[] content)
 {
     if (protocol == HslProtocol.ProtocolCheckSecends)
     {
         BitConverter.GetBytes(DateTime.Now.Ticks).CopyTo(content, 8);
         SendBytes(receive, NetSupport.CommandBytes(HslProtocol.ProtocolCheckSecends, customer, KeyToken, content));
         receive.HeartTime = DateTime.Now;
     }
     else if (protocol == HslProtocol.ProtocolClientQuit)
     {
         TcpStateDownLine(receive, true);
     }
     else if (protocol == HslProtocol.ProtocolUserBytes)
     {
         //接收到字节数据
         AcceptByte?.Invoke(receive, customer, content);
         // LogNet?.WriteDebug(LogHeaderText, "Protocol:" + protocol + " customer:" + customer + " name:" + receive.LoginAlias);
     }
     else if (protocol == HslProtocol.ProtocolUserString)
     {
         //接收到文本数据
         string str = Encoding.Unicode.GetString(content);
         AcceptString?.Invoke(receive, customer, str);
         // LogNet?.WriteDebug(LogHeaderText, "Protocol:" + protocol + " customer:" + customer + " name:" + receive.LoginAlias);
     }
 }
Beispiel #2
0
 /// <summary>
 /// 客户端的数据处理中心
 /// </summary>
 /// <param name="receive"></param>
 /// <param name="protocol"></param>
 /// <param name="customer"></param>
 /// <param name="content"></param>
 internal override void DataProcessingCenter(AsyncStateOne receive, int protocol, int customer, byte[] content)
 {
     if (protocol == HslProtocol.ProtocolCheckSecends)
     {
         DateTime dt = new DateTime(BitConverter.ToInt64(content, 0));
         ServerTime         = new DateTime(BitConverter.ToInt64(content, 8));
         DelayTime          = (int)(DateTime.Now - dt).TotalMilliseconds;
         stateone.HeartTime = DateTime.Now;
         // MessageAlerts?.Invoke("心跳时间:" + DateTime.Now.ToString());
     }
     else if (protocol == HslProtocol.ProtocolClientQuit)
     {
         // 申请了退出
     }
     else if (protocol == HslProtocol.ProtocolUserBytes)
     {
         // 接收到字节数据
         AcceptByte?.Invoke(stateone, customer, content);
     }
     else if (protocol == HslProtocol.ProtocolUserString)
     {
         // 接收到文本数据
         string str = Encoding.Unicode.GetString(content);
         AcceptString?.Invoke(stateone, customer, str);
     }
 }
Beispiel #3
0
 internal override void SocketReceiveException(AsyncStateOne receive, Exception ex)
 {
     if (ex.Message.Contains(StringResources.SocketRemoteCloseException))
     {
         //异常掉线
         TcpStateDownLine(receive, false);
     }
 }
Beispiel #4
0
        /// <summary>
        /// 重新开始接收数据
        /// </summary>
        /// <exception cref="ArgumentNullException"></exception>
        ///
        private void RefreshReceive()
        {
            AsyncStateOne state = new AsyncStateOne();

            state.WorkSocket   = WorkSocket;
            state.UdpEndPoint  = new IPEndPoint(IPAddress.Any, 0);
            state.BytesContent = new byte[ReceiveCacheLength];
            //WorkSocket.BeginReceiveFrom(state.BytesHead, 0, 8, SocketFlags.None, ref state.UdpEndPoint, new AsyncCallback(ReceiveAsyncCallback), state);
            WorkSocket.BeginReceiveFrom(state.BytesContent, 0, ReceiveCacheLength, SocketFlags.None, ref state.UdpEndPoint, new AsyncCallback(AsyncCallback), state);
        }
Beispiel #5
0
        /// <summary>
        /// 通信出错后的处理
        /// </summary>
        /// <param name="receive"></param>
        /// <param name="ex"></param>
        internal override void SocketReceiveException(AsyncStateOne receive, Exception ex)
        {
            if (ex.Message.Contains(StringResources.SocketRemoteCloseException))
            {
                // 异常掉线
                ReconnectServer();
            }
            else
            {
                // MessageAlerts?.Invoke("数据接收出错:" + ex.Message);
            }

            LogNet?.WriteDebug(LogHeaderText, "Socket Excepiton Occured.");
        }
Beispiel #6
0
        /***********************************************************************************************************
        *
        *    无法使用如下的字节头接收来确认网络传输,总是报错为最小
        *
        ***********************************************************************************************************/

        //private void ReceiveAsyncCallback(IAsyncResult ar)
        //{
        //    if (ar.AsyncState is AsyncStateOne state)
        //    {
        //        try
        //        {
        //            state.AlreadyReceivedHead += state.WorkSocket.EndReceiveFrom(ar, ref state.UdpEndPoint);
        //            if (state.AlreadyReceivedHead < state.HeadLength)
        //            {
        //                //接续接收头数据
        //                WorkSocket.BeginReceiveFrom(state.BytesHead, state.AlreadyReceivedHead, state.HeadLength - state.AlreadyReceivedHead, SocketFlags.None,
        //                    ref state.UdpEndPoint, new AsyncCallback(ReceiveAsyncCallback), state);
        //            }
        //            else
        //            {
        //                //开始接收内容
        //                int ReceiveLenght = BitConverter.ToInt32(state.BytesHead, 4);
        //                if (ReceiveLenght > 0)
        //                {
        //                    state.BytesContent = new byte[ReceiveLenght];
        //                    WorkSocket.BeginReceiveFrom(state.BytesContent, state.AlreadyReceivedContent, state.BytesContent.Length - state.AlreadyReceivedContent,
        //                        SocketFlags.None, ref state.UdpEndPoint, new AsyncCallback(ContentReceiveAsyncCallback), state);
        //                }
        //                else
        //                {
        //                    //没有内容了
        //                    ThreadDealWithReveice(state, BitConverter.ToInt32(state.BytesHead, 0), state.BytesContent);
        //                    state = null;
        //                    RefreshReceive();
        //                }
        //            }
        //        }
        //        catch(Exception ex)
        //        {
        //            LogHelper.SaveError(StringResources.异步数据结束挂起发送出错, ex);
        //        }


        //    }
        //}

        //private void ContentReceiveAsyncCallback(IAsyncResult ar)
        //{
        //    if (ar.AsyncState is AsyncStateOne state)
        //    {
        //        try
        //        {
        //            state.AlreadyReceivedContent += state.WorkSocket.EndReceiveFrom(ar, ref state.UdpEndPoint);
        //            if (state.AlreadyReceivedContent < state.BytesContent.Length)
        //            {
        //                //还需要继续接收
        //                WorkSocket.BeginReceiveFrom(state.BytesContent, state.AlreadyReceivedContent, state.BytesContent.Length - state.AlreadyReceivedContent,
        //                        SocketFlags.None, ref state.UdpEndPoint, new AsyncCallback(ContentReceiveAsyncCallback), state);
        //            }
        //            else
        //            {
        //                //接收完成了
        //                ThreadDealWithReveice(state, BitConverter.ToInt32(state.BytesHead, 0), new byte[0]);
        //                state = null;
        //                RefreshReceive();
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            LogHelper.SaveError(StringResources.异步数据结束挂起发送出错, ex);
        //        }


        //    }
        //}

        #region 数据中心处理块

        /// <summary>
        /// 数据处理中心
        /// </summary>
        /// <param name="receive"></param>
        /// <param name="protocol"></param>
        /// <param name="customer"></param>
        /// <param name="content"></param>
        internal override void DataProcessingCenter(AsyncStateOne receive, int protocol, int customer, byte[] content)
        {
            LogNet?.WriteDebug(LogHeaderText, "Protocol:" + protocol + " customer:" + customer + " ip:" + receive.GetRemoteEndPoint().Address.ToString());
            if (protocol == HslCommunicationCode.Hsl_Protocol_User_Bytes)
            {
                AcceptByte?.Invoke(receive, customer, content);
            }
            else if (protocol == HslCommunicationCode.Hsl_Protocol_User_String)
            {
                //接收到文本数据
                string str = Encoding.Unicode.GetString(content);
                AcceptString?.Invoke(receive, customer, str);
            }
        }
Beispiel #7
0
        private void TcpStateUpLine(AsyncStateOne state)
        {
            HybirdLockSockets.Enter();
            All_sockets_connect.Add(state);
            HybirdLockSockets.Leave();

            // 提示上线
            ClientOnline?.Invoke(state);
            // 是否保存上线信息
            if (IsSaveLogClientLineChange)
            {
                LogNet?.WriteInfo(LogHeaderText, "IP:" + state.IpAddress + " Name:" + state?.LoginAlias + " " + StringResources.NetClientOnline);
            }
            // 计算客户端在线情况
            AsyncCoordinator.StartOperaterInfomation();
        }
Beispiel #8
0
        private void TcpStateDownLine(AsyncStateOne state, bool is_regular)
        {
            HybirdLockSockets.Enter();
            All_sockets_connect.Remove(state);
            HybirdLockSockets.Leave();
            // 关闭连接
            TcpStateClose(state);
            // 判断是否正常下线
            string str = is_regular ? StringResources.NetClientOffline : StringResources.NetClientBreak;

            ClientOffline?.Invoke(state, str);
            // 是否保存上线信息
            if (IsSaveLogClientLineChange)
            {
                LogNet?.WriteInfo(LogHeaderText, "IP:" + state.IpAddress + " Name:" + state?.LoginAlias + " " + str);
            }
            // 计算客户端在线情况
            AsyncCoordinator.StartOperaterInfomation();
        }
Beispiel #9
0
 private void SendBytes(AsyncStateOne stateone, byte[] content)
 {
     SendBytesAsync(stateone, content);
 }
Beispiel #10
0
 /// <summary>
 /// 服务器端用于发送字节的方法
 /// </summary>
 /// <param name="stateone">数据发送对象</param>
 /// <param name="customer">用户自定义的数据对象,如不需要,赋值为0</param>
 /// <param name="bytes">实际发送的数据</param>
 public void Send(AsyncStateOne stateone, NetHandle customer, byte[] bytes)
 {
     SendBytes(stateone, NetSupport.CommandBytes(customer, KeyToken, bytes));
 }
Beispiel #11
0
 /// <summary>
 /// 服务器端用于数据发送文本的方法
 /// </summary>
 /// <param name="stateone">数据发送对象</param>
 /// <param name="customer">用户自定义的数据对象,如不需要,赋值为0</param>
 /// <param name="str">发送的文本</param>
 public void Send(AsyncStateOne stateone, NetHandle customer, string str)
 {
     SendBytes(stateone, NetSupport.CommandBytes(customer, KeyToken, str));
 }
Beispiel #12
0
        /// <summary>
        /// 登录后的处理方法
        /// </summary>
        /// <param name="obj"></param>
        protected override void ThreadPoolLogin(object obj)
        {
            if (obj is Socket socket)
            {
                // 判断连接数是否超出规定
                if (All_sockets_connect.Count > ConnectMax)
                {
                    socket?.Close();
                    LogNet?.WriteWarn(LogHeaderText, StringResources.NetClientFull);
                    return;
                }

                // 接收用户别名并验证令牌
                OperateResult result = new OperateResult();
                if (!ReceiveStringFromSocket(
                        socket,
                        out int customer,
                        out string login_alias,
                        result,
                        null
                        ))
                {
                    socket?.Close();
                    return;
                }



                // 登录成功
                AsyncStateOne stateone = new AsyncStateOne()
                {
                    WorkSocket = socket,
                    LoginAlias = login_alias,
                    IpEndPoint = (IPEndPoint)socket.RemoteEndPoint,
                    IpAddress  = ((IPEndPoint)socket.RemoteEndPoint).Address.ToString(),
                };


                if (customer == 1)
                {
                    // 电脑端客户端
                    stateone.ClientType = "Windows";
                }
                else if (customer == 2)
                {
                    // Android 客户端
                    stateone.ClientType = "Android";
                }


                try
                {
                    stateone.WorkSocket.BeginReceive(stateone.BytesHead, stateone.AlreadyReceivedHead,
                                                     stateone.BytesHead.Length - stateone.AlreadyReceivedHead, SocketFlags.None,
                                                     new AsyncCallback(HeadReceiveCallback), stateone);
                    TcpStateUpLine(stateone);
                    Thread.Sleep(500);//留下一些时间进行反应
                }
                catch (Exception ex)
                {
                    //登录前已经出错
                    TcpStateClose(stateone);
                    LogNet?.WriteException(LogHeaderText, StringResources.NetClientLoginFailed, ex);
                }
            }
        }
Beispiel #13
0
 private void TcpStateClose(AsyncStateOne state)
 {
     state?.WorkSocket.Close();
 }