Peer.Lib 1.2.2

peer 通讯协议

基于tcp实现的高效通讯协议

服务端示例

   // 自定义序列化
     public class CJsonConverter : BaseConverter
    {
        public override T Deserialize<T>(byte[] bytes)
        {
            return JsonConvert.DeserializeObject<T>(Encoding.UTF8.GetString(bytes));
        }

        public override object DeserializeObject(byte[] bytes, Type type)
        {
            return JsonConvert.DeserializeObject(Encoding.UTF8.GetString(bytes), type);
        }

        public override byte[] Serialize(object data)
        {
            return Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(data));
        }
    }
    internal class Program
    {

        static void Main(string[] args)
        {
            using PeerServer peerServer = new PeerServer("123123", new IPEndPoint(IPAddress.Any, 9900), new PeerOptions(new CJsonConverter()));
            peerServer.OnAccept += PeerServer_OnAccept;
            peerServer.Listen();
        }

        private static void PeerServer_OnAccept(object sender, PeerStream e)
        {
            Console.WriteLine("链接");
            e.OnReceive += E_OnReceive;
            e.OnError += E_OnError;
            e.OnDisconnect += E_OnDisconnect;
            e.SendAnyAsync("主动向客户端发消息");
        }

        private static void E_OnDisconnect(object sender, PeerStream e)
        {
            Console.WriteLine("断开");
        }

        private static void E_OnError(object sender, Exception e)
        {
            // 错误
            Console.WriteLine((e.InnerException ?? e).Message);
        }

        private static PeerResponse E_OnReceive(PeerStream peer, PeerRequest request)
        {
            // 响应相同结果给客户端
            var paramters = request.GetParameters();
            var sss = paramters.GetNext<string>();

            return request.CreateResponse(sss);
        }
    }

客户端示例

    
    internal class Program
    {

        static void Main(string[] args)
        {
            PeerClient peerClient = new PeerClient("123123", IPEndPoint.Parse("127.0.0.1:9900"));
            peerClient.OnReceive += PeerClient_OnReceive;
            peerClient.OnDisconnect += PeerClient_OnDisconnect;
            peerClient.OnConnected += PeerClient_OnConnected;
            peerClient.OnError += PeerClient_OnError;
            // 重连机制
            peerClient.WithAutomaticReconnect(count => TimeSpan.FromSeconds(count switch
            {
                0 => 1,
                1 => 2,
                2 => 5,
                3 => 10,
                _ => 60
            }))
                .Connect();

            Console.ReadLine();
        }

        private static void PeerClient_OnError(object sender, Exception e)
        {
            Console.WriteLine((e.InnerException ?? e).Message);
        }

        private static void PeerClient_OnConnected(object sender, PeerStream e)
        {
            Console.WriteLine("连接成功");
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();

            for (int i = 0; i < 10000; i++)
            {
                // 发送 并 响应结果
                var res = e.SendAnyWithResponseAsync<string>("马上ssss三四次").GetAwaiter().GetResult();

            }
        
            stopwatch.Stop();
            Console.WriteLine("Client QPS:" + 10000d / stopwatch.ElapsedMilliseconds * 1000);
        }

        private static void PeerClient_OnDisconnect(object sender, PeerStream e)
        {
            Console.WriteLine("断开了");
        }

        /// <summary>
        /// 接收服务器消息
        /// </summary>
        /// <param name="peer"></param>
        /// <param name="request"></param>
        /// <returns></returns>
        private static PeerResponse PeerClient_OnReceive(PeerStream peer, PeerRequest request)
        {
            Console.WriteLine("接收服务器消息：" + request.GetParameters().GetNext<string>());
            return request.CreateResponse();
        }
    }