Socket 心跳 第二篇

 

首先需要引用 

using SuperSocket.ProtoBase;
using SuperSocket.ClientEngine;

 

 

 

public class bb
    {
        static EasyClient<MyPackageInfo> client = null;
        static System.Timers.Timer timer = null;
        string _Ip = null;
        int _Port = 0;
        string _SendContent = null;
        int _HeartbeatTime = 0;
        public MonitorClientCommCoreTwo(string Ip, int Port, string SendContent, int HeartbeatTime = 1)
        {
            this._Ip = Ip;
            this._Port = Port;
            this._SendContent = SendContent;
            this._HeartbeatTime = HeartbeatTime;
        }
        public async void connectServer()
        {
            client = new EasyClient<MyPackageInfo>();
            client.Initialize(new MyReceiveFilter());
            client.Connected += OnClientConnected;
            client.NewPackageReceived += OnPackageReceived;
            client.Error += OnClientError;
            client.Closed += OnClientClosed;
            var connected = await client.ConnectAsync(new IPEndPoint(IPAddress.Parse(_Ip), _Port));
            if (connected)
            {
                //name 2 length 2 body 6 bit 心跳包
                var rs = new List<byte> { 0, 1, 0, 6 };
                rs.AddRange(System.Text.Encoding.UTF8.GetBytes("--发送数据："+_SendContent +"   Time:"+ DateTime.Now.ToString("1ssfff")));

                LogUtils.Info("发送数据：" + DataHelper.ByteToHex(rs.ToArray(), rs.Count));
                client.Send(rs.ToArray());


                //每5秒发一次心跳
                timer = new System.Timers.Timer(_HeartbeatTime * 1000);
                timer.Elapsed += new System.Timers.ElapsedEventHandler((s, x) =>
                {
                    if (client.IsConnected)
                    {
                        rs = new List<byte> { 0, 2, 0, 6 };
                        rs.AddRange(DateTime.Now.ToString("yy MM dd HH mm ss").Split(' ').Select(m => byte.Parse(m)).ToArray());

                        LogUtils.Info("发送数据：" + DataHelper.ByteToHex(rs.ToArray(), rs.Count));
                        client.Send(rs.ToArray());
                    }
                });
                timer.Enabled = true;
                timer.Start();
            }
            else
            {
                LogUtils.Info("连接服务器失败");
            }
        }

        private void OnPackageReceived(object sender, PackageEventArgs<MyPackageInfo> e)
        {
            LogUtils.Info("收到文本下行：" + e.Package.Body);
            //16进制
            //LogHelper.WriteLog("下行：" + DataHelper.ByteToHex(e.Package.Header, e.Package.Header.Length) + DataHelper.ByteToHex(e.Package.Data, e.Package.Data.Length));

            //回复服务端确认
            if ((e.Package.Header[0] * 256 + e.Package.Header[1]) == 4)
            {
                var arr = new List<byte> { 0, 4, 0, 1, 1 };
                client.Send(arr.ToArray());
            }
        }

        private void OnClientConnected(object sender, EventArgs e)
        {
            LogUtils.Info("已连接到服务器...");
        }

        private void OnClientClosed(object sender, EventArgs e)
        {
            if (timer != null)
            {
                timer.Dispose();
            }
            LogUtils.Info("连接已断开...");
        }

        private void OnClientError(object sender, object e)
        {
            LogUtils.Info("客户端错误：");
        }

        private void btnConn_Click(object sender, EventArgs e)
        {
            if (client == null || !client.IsConnected)
                connectServer();
        }
    }
    public class DataHelper
    {
        public static string ByteToHex(byte comByte)
        {
            return comByte.ToString("X2") + " ";
        }
        public static string ByteToHex(byte[] comByte, int len)
        {
            string returnStr = "";
            if (comByte != null)
            {
                for (int i = 0; i < len; i++)
                {
                    returnStr += comByte[i].ToString("X2") + " ";
                }
            }
            return returnStr;
        }
        public static byte[] HexToByte(string msg)
        {
            msg = msg.Replace(" ", "");

            byte[] comBuffer = new byte[msg.Length / 2];
            for (int i = 0; i < msg.Length; i += 2)
            {
                comBuffer[i / 2] = (byte)Convert.ToByte(msg.Substring(i, 2), 16);
            }

            return comBuffer;
        }
        public static string HEXToASCII(string data)
        {
            data = data.Replace(" ", "");
            byte[] comBuffer = new byte[data.Length / 2];
            for (int i = 0; i < data.Length; i += 2)
            {
                comBuffer[i / 2] = (byte)Convert.ToByte(data.Substring(i, 2), 16);
            }
            string result = Encoding.Default.GetString(comBuffer);
            return result;
        }
        public static string ASCIIToHEX(string data)
        {
            StringBuilder result = new StringBuilder(data.Length * 2);
            for (int i = 0; i < data.Length; i++)
            {
                result.Append(((int)data[i]).ToString("X2") + " ");
            }
            return Convert.ToString(result);
        }
    }
    public class MyReceiveFilter : FixedHeaderReceiveFilter<MyPackageInfo>
    {
        /// +-------+---+-------------------------------+
        /// |request| l |                               |
        /// | name  | e |    request body               |
        /// |  (2)  | n |                               |
        /// |       |(2)|                               |
        /// +-------+---+-------------------------------+
        public MyReceiveFilter()
        : base(4)
        {

        }
        protected override int GetBodyLengthFromHeader(IBufferStream bufferStream, int length)
        {
            ArraySegment<byte> buffers = bufferStream.Buffers[0];
            byte[] array = buffers.ToArray();
            int len = array[length - 2] * 256 + array[length - 1];
            //int len = (int)array[buffers.Offset + 2] * 256 + (int)array[buffers.Offset + 3];
            return len;
        }
        public override MyPackageInfo ResolvePackage(IBufferStream bufferStream)
        {
            //第三个参数用0,1都可以
            byte[] header = bufferStream.Buffers[0].ToArray();
            byte[] bodyBuffer = bufferStream.Buffers[1].ToArray();
            byte[] allBuffer = bufferStream.Buffers[0].Array.CloneRange(0, (int)bufferStream.Length);
            return new MyPackageInfo(header, bodyBuffer);
        }
    }


    public class MyPackageInfo : IPackageInfo
    {
        public MyPackageInfo(byte[] header, byte[] bodyBuffer)
        {
            Header = header;
            Data = bodyBuffer;
        }
        /// <summary>
        /// 服务器返回的字节数据头部
        /// </summary>
        public byte[] Header { get; set; }
        /// <summary>
        /// 服务器返回的字节数据
        /// </summary>
        public byte[] Data { get; set; }
        /// <summary>
        /// 服务器返回的字符串数据
        /// </summary>
        public string Body
        {
            get
            {
                return Encoding.UTF8.GetString(Data);
            }
        }

 

//调用时

Task.Run(() =>
{
bb mcc = new bb(Ip, port, "发送 我爱黎明！", 5);
mcc.connectServer();
});