Socket异步通信及心跳包同时响应逻辑分析（最后附Demo）。

  有段时间没有更博了，刚好最近在做Socket通信的项目，原理大致内容：【二维码-（加logo）】-->提供主机地址和端口号信息（直接使用【ThoughtWorks.QRCode.dll】比较简单就不赘述了，核心方法直接贴出来）。然后使用手机APP扫描进行连接服务器，然后通过TCP/IP协议进行握手传输，接收到的图片按照一定的规则进行排列。实时使用心跳包进行检测，服务器进行实时响应。

一、二维码+logo核心方法：

引用的命名空间是：using ThoughtWorks.QRCode.Codec;随便用一个控件（比如：Image就可以show出来！）

 /// <summary>
        /// 初始化二维码对象并根据传入的信息进行创建
        /// </summary>
        public Bitmap Inilized_QRCode(string Imformation)
        {
            encoder.QRCodeEncodeMode = QRCodeEncoder.ENCODE_MODE.BYTE;//编码方式(注意：BYTE能支持中文，ALPHA_NUMERIC扫描出来的都是数字)
            encoder.QRCodeScale = 10;//大小(值越大生成的二维码图片像素越高)
            encoder.QRCodeVersion = 0;//版本(注意：设置为0主要是防止编码的字符串太长时发生错误)
            encoder.QRCodeErrorCorrect = QRCodeEncoder.ERROR_CORRECTION.M;//错误效验、错误更正(有4个等级)
            Bitmap bp = encoder.Encode(Imformation, Encoding.GetEncoding("GB2312"));//进行位图编码
            Image image = bp;
            return bp;
        }

二、重点分析心跳包与握手协议：

本次采用的是Socket进行异步传输，首先要定义服务器地址和端口号（区分网路上其他主机的唯一标识）；开始之前先申明：本文采用的机制是一个客户端只使用一个Socket，服务器通过端口进行监听，并发响应客户端。

* 服务器

A、定义Socket 和 获取 监听服务器本机地址 端口号

 //监听初始化
        private Socket listener = null;//连接客户端
        private Socket RemoteClient = null;//接收消息

        private int port = 8089;
        private IPEndPoint listenEP = null;

B、定义好之后开始初始化数据 ，使用AcceptCallback 进行消息回调并等待客户端触发接收数据

  private void RunsSocketServer()
        {
            listener = new Socket(
                 AddressFamily.InterNetwork,
                 SocketType.Stream,
                 ProtocolType.Tcp);
            listener.Bind(listenEP);
            listener.Listen(10);
            listener.BeginAccept(
                new AsyncCallback(AcceptCallback),
                null);

            LB_TXT.Content = "监听已开启" + listener.LocalEndPoint.ToString() + "";

        }

C、回调函数

 private void AcceptCallback(IAsyncResult iar)
        {
            try
            {
                RemoteClient = listener.EndAccept(iar);
                //同进程上的线程异步
                this.Dispatcher.BeginInvoke((MethodInvoker)delegate ()
                {
                    LB_TXT.Content = string.Format("{0}已连接到服务器", RemoteClient.RemoteEndPoint.ToString());
                });

                ReceivePicHandShakes();//握手协议及接收图片

            }
            catch (Exception err)
            {
                this.Dispatcher.BeginInvoke((MethodInvoker)delegate ()
                 {
                     LB_TXT.Content = err.Message;
                 });
                return;
            }
        }

D、通过开辟一个新的线程进行异步接收数据(图中的协议使用XXX代替，请大家根据自己的协议需要进行定义)

  Thread _timers = null;
        private Socket _SocketClient = null;
        byte[] RecvBytes = new byte[50];
        private int Numimgs = 0;//记录接收成功的张数
        //byte[] ReImgBytes = new byte[8];//接收图片的头字节
        public event ReceivedBitmapHandler ReceivedBitmap;
        private delegate void RestartThread();//定义委托


        public TransferHandler(Socket client)
        {
            _SocketClient = client;
        }

        #region 服务器端
        public void BeginReceive()
        {
            //采用线程直接接收的方式
            _timers = new Thread(StartToReceive);
            _timers.IsBackground = true;
            _timers.Start();
        }
        /// <summary>
        /// 开始接收消息
        /// </summary>
        private void StartToReceive()
        {
            //由于long占8位字节，所以先获取前8位字节数据
            IAsyncResult iar = _SocketClient.BeginReceive(
                RecvBytes,
                0,
                RecvBytes.Length,
                SocketFlags.None,
                null,
                null);
            int len = _SocketClient.EndReceive(iar);
            string ReceivemMsg = Encoding.ASCII.GetString(RecvBytes, 0, len);
            if (ReceivemMsg.IndexOf("xxx") > 0)//区分业务消息和心跳检测消息
            {
                _SocketClient.Send(Encoding.ASCII.GetBytes("xxx"));//回应心跳包
                RecvBytes = new byte[RecvBytes.Length]; //清空数据
                StartToReceive();//回应心跳包完成之后继续等待接收
            }
            else if (ReceivemMsg == "xxx")//如果收到这个请求，告诉客户端可以开始发送第一张图片了
            {
                string order = "xxx";
                byte[] orderdata = Encoding.ASCII.GetBytes(order);   //把字符串编码为字节
                _SocketClient.Send(orderdata);
                RecvBytes = new byte[8]; //开始接收图片
                StartToReceive();//回应指令后完成之后继续等待接收
            }
            else if (ReceivemMsg == "xxx")
            {
                //停止接收图片
                string order = "xxxx";//通知客户端已经完成接收这次所有图片，结束传输;
                byte[] orderdata = Encoding.ASCII.GetBytes(order);   //把字符串编码为字节
                _SocketClient.Send(orderdata);
                StartToReceive();
            }
            else
            {
                int offset = 0;
                int length = BitConverter.ToInt32(RecvBytes, offset);  //先获取文件长度
                ReceiveFile(length);
            }

        }


        public void ReceiveFile(long filelen)
        {
            MemoryStream ms = new MemoryStream();
            int bytesRead = 0;
            long count = 0;
            byte[] buffer = new byte[8192];

            while (count != filelen)
            {
                try
                {
                    bytesRead = _SocketClient.Receive(buffer);
                    ms.Write(buffer, 0, bytesRead);
                    count += bytesRead;
                }
                catch (Exception ex)
                {

                }
            }
            ReceivedBitmap(new Bitmap(ms));


            //接收完成之后清空数据，继续接收
            buffer = new byte[buffer.Length];//缓存
            RecvBytes = new byte[RecvBytes.Length];//用于接收

            string order = "xxxx";//通知客户端已经收到图片，请继续
            byte[] orderdata = Encoding.ASCII.GetBytes(order);   //把字符串编码为字节
            _SocketClient.Send(orderdata);
            Numimgs++;

            if (Numimgs >= 3)
            {
                RecvBytes = new byte[50];
                Numimgs = 0;
            }
            StartToReceive(); //接收完成之后继续接收
        }
        #endregion

* 客户端

A、心跳包发送(代码中XXX解释同上）

        #region 心跳检测
        private void HeartBeatsTests()
        {
            Thread sendEcho = new Thread(new ThreadStart(socketSend));
            sendEcho.Start();
            sendEcho.IsBackground = true;
        }


        public void socketSend()
        {
            while (true)
            {
                Thread.Sleep(10000);//每十秒发一次,响应发3次
                //备注：IsSendingImgs必须放在sleep底下，防止等待的空余时间发送导致服务端继续接收心跳包
                if (!IsSendingImgs)//如果是任务还在执行不允许第二次发送,必须要等待完成
                {
                    try
                    {
                        this.Dispatcher.BeginInvoke((MethodInvoker)delegate ()
                        {
                            this.richTextBox.AppendText("开始发送心跳包..." + Environment.NewLine);
                        });
                        client.Send(Encoding.ASCII.GetBytes("xxxx"));//发送心跳暗号
                    }
                    catch (SocketException)
                    {
                        Thread.CurrentThread.Abort();
                        //throw ex;
                    }
                    //标记发送的次数
                    this.MyLostTime++;
                    //如果外发了3次请求暗号后仍不见服务器的回应，则认为客户端已经与服务器断开联系了
                    if (this.MyLostTime >= 3)
                    {
                        //IsSendingImgs = true;
                        TimeSpan t = DateTime.Now - lastConnect;
                        if (t.TotalSeconds > 30)
                        {
                            this.Dispatcher.BeginInvoke((MethodInvoker)delegate ()
                            {
                                //this.richTextBox.cont
                                this.richTextBox.AppendText("与服务器失去联系..." + Environment.NewLine);
                            });
                        }
                        else
                        {

                            this.countnum++;
                            this.Dispatcher.BeginInvoke((MethodInvoker)delegate ()
                            {
                                //this.richTextBox.cont
                                this.richTextBox.AppendText("服务器响应第" + countnum.ToString() + "次,响应时间是:" + DateTime.Now.ToString() + "；" + Environment.NewLine);
                            });
                        }
                        //每次确定后重置
                        this.MyLostTime = 0;
                    }
                }
                else
                {
                    lastConnect = DateTime.Now;//每十秒刷新，防止图片传送任务完成之后导致时间错误;
                }
            }

        }

        #endregion

B、响应机制（发送图片及接收消息触发停止、开启心跳包代码中XXX解释同上）

        /// <summary>
        /// 协议请求
        /// </summary>
        public void SendSocketData()
        {
            string sendStr = "xxx"; //向服务器发送请求：发送3张图片的指令
            byte[] buffer = Encoding.ASCII.GetBytes(sendStr);   //把字符串编码为字节
            _SendQuest.Send(buffer); //发送
            _SendQuest.BeginReceive(Rbuffer, 0, Rbuffer.Length, 0, new AsyncCallback(CallbackRuquest), null);//等待接收并回调
        }


        /// <summary>
        /// 回调告诉socket可以执行下一步了
        /// </summary>
        /// <param name="iar"></param>
        private void CallbackRuquest(IAsyncResult arr)
        {
            int aa = _SendQuest.EndReceive(arr);
            string Rc_Msg = Encoding.ASCII.GetString(Rbuffer, 0, aa);
            if (Rc_Msg == "xxx")
            {
                khd.IsSendingImgs = false;//启动心跳包--用于接收完成之后继续开启心跳包用
                Numimgs = 0;
                _SendQuest.BeginReceive(Rbuffer, 0, Rbuffer.Length, 0, new AsyncCallback(CallbackRuquest), null);//等待接收并回调
            }
            else
            {
                //结束接收
                if (Numimgs >= 3)
                {
                    //结束
                    byte[] buffer = Encoding.ASCII.GetBytes("xxx");
                    _SendQuest.Send(buffer);
                    _SendQuest.BeginReceive(buffer, 0, buffer.Length, 0, new AsyncCallback(CallbackRuquest), null);//等待接收并回调
                  
                }
                else
                {
                    //接收成功并进行回调

                    if (Rc_Msg.IndexOf("xxx") > 0)
                    {
                        Socket_Client.lastConnect = DateTime.Now;//重新赋值
                        khd.Dispatcher.BeginInvoke((MethodInvoker)delegate ()
                        {
                            khd.richTextBox.AppendText("接收到服务器的响应消息" + Environment.NewLine);
                        });
                        _SendQuest.BeginReceive(Rbuffer, 0, Rbuffer.Length, 0, new AsyncCallback(CallbackRuquest), null);//等待接收并回调
                    }
                    else if (Rc_Msg == "xxx" || Rc_Msg == "xxx")
                    {
                        FileInfo fi = new FileInfo(Filename);//获取文件
                        byte[] len = BitConverter.GetBytes(fi.Length);//文件数据
                                                                      //首先把文件长度发送过去
                        _SendQuest.BeginSendFile(Filename, len, null, TransmitFileOptions.UseDefaultWorkerThread, new AsyncCallback(EndSendback), null);
                        _SendQuest.BeginReceive(Rbuffer, 0, Rbuffer.Length, 0, new AsyncCallback(CallbackRuquest), null);//等待接收并回调
                                                                                                                         //清空数据
                        len = new byte[fi.Length];
                        Numimgs++;
                    }
                }
            }
        }

        /// <summary>
        /// 结束发送 
        /// </summary>
        /// <param name="eof"></param>
        private void EndSendback(IAsyncResult eof)
        {
            _SendQuest.EndSendFile(eof);
        }

        /// <summary>
        /// 结束接收 
        /// </summary>
        /// <param name="eof"></param>
        private void EndCallback(IAsyncResult eof)
        {
            //结束接收
            _SendQuest.EndReceive(eof);

        }

这边只着重做出如何响应如何发送的逻辑实现，做个笔记。还是蛮有意思的。以下是Demo效果图：

 

此文的Demo下载地址：Socket心跳通信