NetCore3.1 TCP服务之BeetleX

十年河东，十年河西，莫欺少年穷

学无止境，精益求精

详情查看： https://www.cnblogs.com/e4ky/p/12487542.html

1、安装包

2、server端

using BeetleX;
using BeetleX.EventArgs;
using System;

namespace BTcp
{
    
    class Program : BeetleX.ServerHandlerBase
    {
        static int Number = 0;
        private static BeetleX.IServer mServer;
        static void Main(string[] args)
        {
            mServer = SocketFactory.CreateTcpServer<Program>();
            mServer.Options.DefaultListen.Port = 9090;
            mServer.Options.DefaultListen.Host = "127.0.0.1";
            mServer.Open();
            Console.WriteLine(mServer.Status);
            Console.Read();
        }
        protected override void OnLogToConsole(IServer server, ServerLogEventArgs e)
        {

            Console.WriteLine($"{DateTime.Now}\t{e.Type}\t{e.Session?.RemoteEndPoint} {e.Message}");
        }

        public override void SessionReceive(IServer server, SessionReceiveEventArgs e)
        {
            base.SessionReceive(server, e);
            var stream = e.Stream.ToPipeStream();
            if (stream.TryReadLine(out string line))
            {
                Number++;
                Console.WriteLine(line+ "："+Number);
                stream.WriteLine($"{DateTime.Now}");
                e.Stream.Flush();
            }
        }
    }
}

3、客户端

using BeetleX;
using BeetleX.Clients;
using System;
using System.Net.Sockets;
using System.Threading.Tasks;

namespace BTcpClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Parallel.For(0, 10000, i =>
            {
                AsyncTcpClient client = SocketFactory.CreateClient<AsyncTcpClient>("127.0.0.1", 9090);
                client.ClientError = (o, e) =>
                {
                    Console.WriteLine("client error {0}@{1}", e.Message, e.Error);
                };
                client.DataReceive = (o, e) =>
                {
                    Console.WriteLine(e.Stream.ToPipeStream().ReadLine());
                };
                var pipestream = client.Stream.ToPipeStream();
                pipestream.WriteLine("hello BeetleX");
                client.Stream.Flush();
            });
          
            Console.Read();
        }
    }
}

4、测试结果

模拟短时间内，建立10000个链接

2025-06-12更新：

using CoreDbContext.Context;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using NLog.Extensions.Logging;
using PgSqlPublicContext.Context;
using swapCommon.RedisHelpers;
using swapModels.ChargeService;
using swapService.Interface;
using swapService.Service;
using System.Threading.Tasks;

namespace PowerService
{
    class Program
    {
        static void Main(string[] args)
        {
            ConfigurationBuilder builder = new ConfigurationBuilder();
            builder.AddJsonFile("appsettings.json", true, true);
            var ConfigRoot = builder.Build();//根节点
            IServiceCollection Services = new ServiceCollection();
            Services.AddDbContext<swapDbContext>(options => options.UseSqlServer(ConfigRoot.GetConnectionString("swapDbContext")), ServiceLifetime.Scoped);
             

            Services.AddLogging(log => { log.AddConsole(); log.AddNLog(); log.SetMinimumLevel(LogLevel.Error); });

            Services.AddOptions().Configure<TcpOptions>(A => ConfigRoot.GetSection("TcpOptions").Bind(A));
            //  
            Services.AddScoped<RedisDbHelper>(A => new RedisDbHelper(3));

            Services.AddScoped<TcpServerService>();
            //Services.AddScoped<ITcpPowerService, TcpPowerService>();

            //  
            using (ServiceProvider provider = Services.BuildServiceProvider())
            {
                var service = provider.GetService<TcpServerService>();
                service.Start();
            }
            CreateHostBuilder(args).Run();
        }

        public static IHost CreateHostBuilder(string[] args)
        {
            var builder = Host.CreateDefaultBuilder(args)
                 .ConfigureServices((hostContext, services) =>
                 {

                 }).UseWindowsService();
            var host = builder.Build();

            return host;
        }
    }
}

及

using BeetleX.EventArgs;
using BeetleX;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using swapModels.ChargeService;
using System.Collections.Concurrent;
using System.Net.Sockets;
using Autofac.Core;
using swapCommon.RedisHelpers;
using swapModels.TcpModels;
using System.Threading;
using Newtonsoft.Json;
using swapService.Service;
using VOL.Core.Extensions;
using Microsoft.IdentityModel.Tokens;
using Aop.Api.Domain;

namespace PowerService
{
    internal class TcpServerService : BeetleX.ServerHandlerBase
    { 
        public static ConcurrentDictionary<long, ClientDto> Connections = new ConcurrentDictionary<long, ClientDto>();
        private readonly swapCommon.RedisHelpers.RedisDbHelper redis = new swapCommon.RedisHelpers.RedisDbHelper(2); 

        private static BeetleX.IServer mServer;
        public void Start()
        {
            mServer = SocketFactory.CreateTcpServer<TcpServerService>();
            mServer.Options.DefaultListen.Port = 6868;
            mServer.Options.DefaultListen.Host = "0.0.0.0";
            mServer.Open();
            //Console.WriteLine(mServer.Status);
            //Console.Read();
        }
        protected override void OnLogToConsole(IServer server, ServerLogEventArgs e)
        { 
            Console.WriteLine($"{DateTime.Now}\t{e.Type}\t{e.Session?.RemoteEndPoint} {e.Message}");
        }

        public override void Connected(IServer server, ConnectedEventArgs e)
        {
            if (server.Options.SessionTimeOut > 0)
            {
                server.UpdateSession(e.Session);
                var Key = e.Session.ID;
                if (!Connections.Any(A => A.Key == Key))
                {
                    Connections.TryAdd(Key, new ClientDto() {client = e.Session.Socket, ClientOnlineTime = DateTime.Now });
                }

            }

            Console.WriteLine($"session connected from {e.Session.RemoteEndPoint}@{e.Session.ID}");
        }



        public override void Disconnect(IServer server, SessionEventArgs e)
        {
            var Key = e.Session.ID;
            if (Connections.Any(A => A.Key == Key))
            {
                var client = new ClientDto();
                Connections.TryRemove(Key, out client);
            }
            Console.WriteLine($"session disconnected from {e.Session.RemoteEndPoint}@{e.Session.ID}");

        } 

        public override void SessionReceive(IServer server, SessionReceiveEventArgs e)
        {
            base.SessionReceive(server, e);
            var stream = e.Stream.ToPipeStream();
            int len = Convert.ToInt32(stream.Length);
            var msg = stream.ReadString(len);
            TcpPowerBase tcp = JsonConvert.DeserializeObject<TcpPowerBase>(msg);
            if (tcp != null)
            {
                switch (tcp.CMD)
                {
                    //设备上报-登录
                    case 0: LoginReply(tcp, server,e, msg); break;
                    //心跳
                    case 1: HeartReply(tcp, server, e, msg); break;
                    ////30分钟上报
                    //case 2: ElecReply(tcp, e, msg); break;
                    ////设备上报端口异常充电宝数据--文档标明无需回复
                    //case 35: service.ReceiveTcpErrdata(tcp.DEVICE, tcp.CMD, msg); break;

                    ////归还上报
                    //case 3: ResoreReply(tcp, e, msg); break;

                    ////服务器下发后 - 接收租借充电包数据
                    //case 4: TcpReply(tcp, e, msg); break;

                    ////服务器下发后 - 接收强行打开指定端口数据
                    //case 5: TcpReply(tcp, e, msg); break;

                    ////服务器下发后 - 接收查询指定端口的充电宝数据
                    //case 6: TcpReply(tcp, e, msg); break;

                    //////服务器下发后 - 接收查询所有端口的充电宝数据
                    ////case 7: TcpReply(tcp, e, msg); break;

                    ////服务器下发后 - 接收重启设备数据
                    //case 10: TcpReply(tcp, e, msg); break;
                    //    ////服务器下发后 - 接收一次性打开所有端口数据
                    //    //case 20: TcpReply(tcp, e, msg); break;

                }
            }
            e.Stream.Flush();
          
        }



        private void LoginReply(TcpPowerBase tcp,SessionReceiveEventArgs e, string msg)
        {
            Console.WriteLine($"收到设备登录消息：{msg}");
            var Key = e.Session.ID;
            var result = TcpPowerService.GetTcpLoginReply(tcp.DEVICE, tcp.CMD, msg); 
            if (result != null)
            {
                var ResultMsg = JsonConvert.SerializeObject(result);
                //e.Session.Send(Encoding.UTF8.GetBytes(ResultMsg));
                //  server.Send()
                //向设备发送字节时  一定要使用 IWriteHandler
                IWriteHandler write = new BytesHandler(Encoding.UTF8.GetBytes(ResultMsg));
                Server.Send(write, e.Session);
                if (!Connections.Any(A => A.Key == Key))
                {
                    Connections.TryAdd(Key, new ClientDto() { client = e.Session.Socket, ClientOnlineTime = DateTime.Now });
                }
            }
        }

        private void HeartReply(TcpPowerBase tcp, SessionReceiveEventArgs e, string msg)
        {
            Console.WriteLine($"收到设备心跳消息：{msg}");
            var Key = e.Session.ID;
            var result = TcpPowerService.GetTcpHeartReply(tcp.DEVICE, tcp.CMD, msg);
            if (result != null)
            {
                var ResultMsg = JsonConvert.SerializeObject(result);
                //向设备发送字节时  一定要使用 IWriteHandler
                IWriteHandler write = new BytesHandler(Encoding.UTF8.GetBytes(ResultMsg));
                Server.Send(write, e.Session); Console.WriteLine($"回复设备心跳消息：{ResultMsg}");
       
                if (!Connections.Any(A => A.Key == Key))
                {
                    Connections.TryAdd(Key, new ClientDto() { client = e.Session.Socket, ClientOnlineTime = DateTime.Now });
                }
            }
        }
         
    }
    public class ClientDto
    {
        public Socket client { get; set; }
        public string Device { get; set; }
        public DateTime ClientOnlineTime { get; set; }
    }
}

View Code

客户端：

using BeetleX;
using BeetleX.Clients; 

namespace PowerClient
{
    internal class Program
    {
        static void Main(string[] args)
        {
            TcpClient client = SocketFactory.CreateClient<TcpClient>("127.0.0.1", 6868);
            while (true)
            {
                Console.WriteLine(11);
                var line = "hello";
                client.Stream.ToPipeStream().WriteLine(line);
                client.Stream.Flush();
                var reader = client.Receive();
                line = reader.ReadLine();
                Console.WriteLine(line);
                Thread.Sleep(1000 * 10);
            }
        }
    }
}

哈哈哈

using BeetleX.EventArgs;
using BeetleX;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using swapModels.ChargeService;
using System.Collections.Concurrent;
using System.Net.Sockets;
using Autofac.Core;
using swapCommon.RedisHelpers;
using swapModels.TcpModels;
using System.Threading;
using Newtonsoft.Json;
using swapService.Service;
using VOL.Core.Extensions;
using Microsoft.IdentityModel.Tokens;
using Aop.Api.Domain;
using SugarDbContext;

namespace PowerService
{
    internal class TcpServerService : BeetleX.ServerHandlerBase
    { 
        public static ConcurrentDictionary<long, ClientDto> Connections = new ConcurrentDictionary<long, ClientDto>();
        private readonly swapCommon.RedisHelpers.RedisDbHelper redis = new swapCommon.RedisHelpers.RedisDbHelper(3); 

        private static BeetleX.IServer mServer;
        public void Start()
        {
            mServer = SocketFactory.CreateTcpServer<TcpServerService>();
            mServer.Options.DefaultListen.Port = 6868;
            mServer.Options.DefaultListen.Host = "0.0.0.0";
            mServer.Open();
            //Console.WriteLine(mServer.Status);
            //Console.Read();
        }
        protected override void OnLogToConsole(IServer server, ServerLogEventArgs e)
        { 
            Console.WriteLine($"{DateTime.Now}\t{e.Type}\t{e.Session?.RemoteEndPoint} {e.Message}");
        }

        public override void Connected(IServer server, ConnectedEventArgs e)
        {
            if (server.Options.SessionTimeOut > 0)
            {
                server.UpdateSession(e.Session);
                //var Key = e.Session.ID;
                //if (!Connections.Any(A => A.Key == Key))
                //{
                //    Connections.TryAdd(Key, new ClientDto() {session = e.Session, ClientOnlineTime = DateTime.Now });
                //} 
            }

            Console.WriteLine($"session connected from {e.Session.RemoteEndPoint}@{e.Session.ID}");
        }



        public override void Disconnect(IServer server, SessionEventArgs e)
        {
            var Key = e.Session.ID;
            if (Connections.Any(A => A.Key == Key))
            {
                var client = new ClientDto();
                Connections.TryRemove(Key, out client);
            }
            Console.WriteLine($"session disconnected from {e.Session.RemoteEndPoint}@{e.Session.ID}");

        } 

        public override void SessionReceive(IServer server, SessionReceiveEventArgs e)
        {
            base.SessionReceive(server, e);
            var stream = e.Stream.ToPipeStream();
            int len = Convert.ToInt32(stream.Length);
            var msg = stream.ReadString(len);
            TcpPowerBase tcp = JsonConvert.DeserializeObject<TcpPowerBase>(msg);
            if (tcp != null)
            {
                switch (tcp.CMD)
                {
                    //设备上报-登录
                    case 0: LoginReply(tcp, e, msg); break;
                    //心跳
                    case 1: HeartReply(tcp,  e, msg); break;
                    //30分钟上报
                    case 2: ElecReply(tcp, e, msg); break;
                    //设备上报端口异常充电宝数据--文档标明无需回复
                    //case 35: service.ReceiveTcpErrdata(tcp.DEVICE, tcp.CMD, msg); break;

                    ////归还上报
                    case 3: ResoreReply(tcp, e, msg); break;

                    //服务器下发后 - 接收租借充电包数据
                    case 4: TcpReply(tcp, e, msg); break;

                    //服务器下发后 - 接收强行打开指定端口数据
                    case 5: TcpReply(tcp, e, msg); break;

                    //服务器下发后 - 接收查询指定端口的充电宝数据
                    case 6: TcpReply(tcp, e, msg); break;

                    ////服务器下发后 - 接收查询所有端口的充电宝数据
                    case 7: TcpReply(tcp, e, msg); break;

                    //服务器下发后 - 接收重启设备数据
                    case 10: TcpReply(tcp, e, msg); break;
                    ////服务器下发后 - 接收一次性打开所有端口数据
                    case 20: TcpReply(tcp, e, msg); break;

                }
            }
            e.Stream.Flush();
          
        }



        private void LoginReply(TcpPowerBase tcp,SessionReceiveEventArgs e, string msg)
        {
            Console.WriteLine($"收到设备登录消息：{msg}");
            var Key = e.Session.ID;
            var result = TcpPowerService.GetTcpLoginReply(tcp.DEVICE, tcp.CMD, msg); 
            if (result != null)
            {
                var ResultMsg = JsonConvert.SerializeObject(result);
                //e.Session.Send(Encoding.UTF8.GetBytes(ResultMsg));
                //  server.Send()
                //向设备发送字节时  一定要使用 IWriteHandler
                IWriteHandler write = new BytesHandler(Encoding.UTF8.GetBytes(ResultMsg));
                Server.Send(write, e.Session);
                if (!Connections.Any(A => A.Key == Key))
                {
                    Connections.TryAdd(Key, new ClientDto() { session = e.Session, Device=tcp.DEVICE, ClientOnlineTime = DateTime.Now });
                }
            }
        }

        private void HeartReply(TcpPowerBase tcp, SessionReceiveEventArgs e, string msg)
        {
            Console.WriteLine($"收到设备心跳消息：{msg}");
            var Key = e.Session.ID;
            var result = TcpPowerService.GetTcpHeartReply(tcp.DEVICE, tcp.CMD, msg);
            if (result != null)
            {
                var ResultMsg = JsonConvert.SerializeObject(result);
                //向设备发送字节时  一定要使用 IWriteHandler
                IWriteHandler write = new BytesHandler(Encoding.UTF8.GetBytes(ResultMsg));
                Server.Send(write, e.Session);
                Console.WriteLine($"回复设备心跳消息：{ResultMsg}");
       
                if (!Connections.Any(A => A.Key == Key))
                {
                    Connections.TryAdd(Key, new ClientDto() { session = e.Session, Device = tcp.DEVICE, ClientOnlineTime = DateTime.Now });
                }
            }
        }

        private void ElecReply(TcpPowerBase tcp, SessionReceiveEventArgs e, string msg)
        {
            string sql = string.Format("insert into Rbt_Logs values(newid(),'{0}',getdate())", msg);
            DataRepository.ExecuteCommand(sql);
            var result = TcpPowerService.GetTcpElecReply(tcp.DEVICE, tcp.CMD, msg);
            if (result != null)
            {
                var ResultMsg = JsonConvert.SerializeObject(result);
                //向设备发送字节时  一定要使用 IWriteHandler
                IWriteHandler write = new BytesHandler(Encoding.UTF8.GetBytes(ResultMsg));
                Server.Send(write, e.Session);
                 
            }
        }

        private void ResoreReply(TcpPowerBase tcp, SessionReceiveEventArgs e, string msg)
        {
            string sql = string.Format("insert into Rbt_Logs values(newid(),'{0}',getdate())", msg);
            DataRepository.ExecuteCommand(sql);
            var result = TcpPowerService.GetTcpResoreReply(tcp.DEVICE, tcp.CMD, msg);
            if (result != null)
            {
                var ResultMsg = JsonConvert.SerializeObject(result);
                //向设备发送字节时  一定要使用 IWriteHandler
                IWriteHandler write = new BytesHandler(Encoding.UTF8.GetBytes(ResultMsg));
                Server.Send(write, e.Session);

                Thread.Sleep(1000);
                //归还后 主动查询所有端口信息
                TcpSeeAllSnDto dto = new TcpSeeAllSnDto()
                {
                    CMD = 6,
                    DEVICE = tcp.DEVICE,
                    SEQ = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
                    PORT = 255
                };
                SendMsg(tcp.DEVICE, JsonConvert.SerializeObject(dto));
            }
        }

        private void TcpReply(TcpPowerBase tcp, SessionReceiveEventArgs e, string msg)
        {
            string sql = string.Format("insert into Rbt_Logs values(newid(),'{0}',getdate())", msg);
            DataRepository.ExecuteCommand(sql);

            //发 接 指令一至  需要用Connections做判断
            var dic = Connections.Where(A => A.Key==e.Session.ID).FirstOrDefault();
            if (dic.Key == 0) 
            { 
                //webAPi 临时连接 发送指令 这里先回复webApi 然后 负责转发到设备
                SendMsg(tcp.DEVICE, msg);
                //寻找转发的设备
                var device = Connections.Where(A => A.Value.Device == tcp.DEVICE).FirstOrDefault();
                if (tcp.CMD == 4 || tcp.CMD == 5)
                {
                    Thread.Sleep(1000);
                    TcpSeeAllSnDto dto = new TcpSeeAllSnDto()
                    {
                        CMD = 6,
                        DEVICE = tcp.DEVICE,
                        SEQ = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
                        PORT = 255
                    };
                    SendMsg(tcp.DEVICE, JsonConvert.SerializeObject(dto));
                }

            }
            else
            {
                //接收设备响应
                var rdskey = tcp.DEVICE + tcp.CMD + tcp.SEQ;
                redis.StringSet(rdskey, msg, TimeSpan.FromMinutes(2));
               
                Console.WriteLine("服务器接收数据：" + msg);
                if (tcp.CMD == 6)
                {
                    //更新缓存
                    TcpLoginDto dto = JsonConvert.DeserializeObject<TcpLoginDto>(msg);
                    PowerInfoDto info = new PowerInfoDto()
                    {
                        DEVICE = tcp.DEVICE,
                        BATT = dto.BATT
                    };
                    var key = string.Format(RedisKeys.PowerInfoKey, tcp.DEVICE);
                    redis.StringSet(key, JsonConvert.SerializeObject(info), TimeSpan.FromMinutes(30));
                }
            }
        }


        //private void SeeAllSn(TcpPowerBase tcp, Message e, string msg)
        //{
        //    //发送指令后,设备响应结果
        //    if (msg.IndexOf("BATT") > -1)
        //    {
        //        //
        //        var rdskey = tcp.DEVICE + tcp.CMD + tcp.SEQ;
        //        redis.StringSet(rdskey, msg, TimeSpan.FromMinutes(2));
        //        Console.WriteLine("服务器接收数据：" + msg);
        //    }
        //    else
        //    {
        //        SendMsg(tcp.DEVICE, Encoding.UTF8.GetBytes(msg));
        //    }
        //}

        //private void SeePortSn(TcpPowerBase tcp, Message e, string msg)
        //{
        //    //发送指令后,设备响应结果
        //    if (msg.IndexOf("BATT") > -1)
        //    {
        //        //
        //        var rdskey = tcp.DEVICE + tcp.CMD + tcp.SEQ;
        //        redis.StringSet(rdskey, msg, TimeSpan.FromMinutes(2));
        //        Console.WriteLine("服务器接收数据：" + msg);
        //    }
        //    else
        //    {
        //        SendMsg(tcp.DEVICE, Encoding.UTF8.GetBytes(msg));
        //    }
        //}


        private void SendMsg(string DeviceNo, string msg)
        {
            Console.WriteLine("当前连接数：" + Connections.Count);
         
            if (Connections.Count > 0)
            {
                var dic = Connections.Where(A => A.Value.Device == DeviceNo).OrderByDescending(A => A.Value.ClientOnlineTime).FirstOrDefault();
                if (dic.Key > 0)
                {
                    IWriteHandler write = new BytesHandler(Encoding.UTF8.GetBytes(msg));
                    Server.Send(write, dic.Value.session); 
                }
            }
        }
    }
    public class ClientDto
    { 
        public ISession session { get; set; }
        public string Device { get; set; }
        public DateTime ClientOnlineTime { get; set; }
    }
}

View Code

WEBAPI

using BeetleX;
using BeetleX.Clients;
using CoreDbContext.Context;
using Newtonsoft.Json; 
using swapCommon;
using swapModels.TcpModels;
using swapService.Interface.Power;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace swapService.Service.Power
{
    /// <summary>
    /// 小程序专用
    /// </summary>
    public class PowerService : IPowerService
    {
        private string Url = "xxx.com";
        private int servicePort = 6558;
        private readonly swapDbContext context;
        private readonly swapCommon.RedisHelpers.RedisDbHelper redis; 
        public PowerService(swapDbContext context, swapCommon.RedisHelpers.RedisDbHelper redis)
        {
            this.context = context;
            this.redis = redis; 
        }



        /// <summary>
        /// 868739050919376
        /// </summary>
        /// <param name="device">868739050919376</param>
        /// <returns></returns>
        public TcpReStartReturnDto ReStartDevice(string device)
        { 
            TcpClient client = SocketFactory.CreateClient<TcpClient>(Url, servicePort);
  

            TcpReStartDto tcp = new TcpReStartDto()
            {
                CMD = 10,
                DEVICE = device,
                SEQ = DateTime.Now.ToString("yyyyMMddHHmmssfff")

            };
            //发送心跳 
            //发送
            client.Stream.ToPipeStream().WriteLine(JsonConvert.SerializeObject(tcp));
            client.Stream.Flush();

            client.DisConnect();
            client.Dispose();

            for (int i = 0; i < 20; i++)
            {
                Thread.Sleep(1000);
                var rdskey = tcp.DEVICE + tcp.CMD + tcp.SEQ;
                var RdsResult = redis.StringGet(rdskey);
                if (!string.IsNullOrEmpty(RdsResult))
                {
                    return JsonConvert.DeserializeObject<TcpReStartReturnDto>(RdsResult);
                }
            }

            return null;
        }
          
        /// <summary>
        /// 借
        /// </summary>
        /// <param name="device"></param>
        /// <returns></returns>
        public TcpLendReturnDto LendDevice(string device)
        { 
            TcpClient client = SocketFactory.CreateClient<TcpClient>(Url, servicePort);
             

            TcpLendDto tcp = new TcpLendDto()
            {
                CMD = 4,
                DEVICE = device,
                EQP = 80,
                TIME = TimeHelper.GetTimestamp(),
                SEQ = DateTime.Now.ToString("yyyyMMddHHmmssfff")

            };
            //发送
            client.Stream.ToPipeStream().WriteLine(JsonConvert.SerializeObject(tcp));
            client.Stream.Flush();

            client.DisConnect();
            client.Dispose();
            for (int i = 0; i < 20; i++)
            {
                Thread.Sleep(1000);
                var rdskey = tcp.DEVICE + tcp.CMD + tcp.SEQ;
                var RdsResult = redis.StringGet(rdskey);
                if (!string.IsNullOrEmpty(RdsResult))
                {
                    return JsonConvert.DeserializeObject<TcpLendReturnDto>(RdsResult);
                }
            } 

            return null;
        }

        public TcpOpenPortReturnDto OpenByPort(string device, int Port)
        {
            TcpClient client = SocketFactory.CreateClient<TcpClient>(Url, servicePort);

            //
            TcpOpenPortDto tcp = new TcpOpenPortDto()
            {
                CMD = 5,
                DEVICE = device,
                PORT = Port,
                TIME = TimeHelper.GetTimestamp(),
                SEQ = DateTime.Now.ToString("yyyyMMddHHmmssfff")
            };
            //发送
            client.Stream.ToPipeStream().WriteLine(JsonConvert.SerializeObject(tcp));
            client.Stream.Flush();

            client.DisConnect();
            client.Dispose();
            for (int i = 0; i < 20; i++)
            {
                Thread.Sleep(1000);
                var rdskey = tcp.DEVICE + tcp.CMD + tcp.SEQ;
                var RdsResult = redis.StringGet(rdskey);
                if (!string.IsNullOrEmpty(RdsResult))
                {
                    return JsonConvert.DeserializeObject<TcpOpenPortReturnDto>(RdsResult);
                }
            }


            return null;
        }

        /// <summary>
        /// 之哦了
        /// </summary>
        /// <param name="device"></param>
        /// <returns></returns>
        public TcpOpenAllPortReturnDto OpenAllPort(string device)
        {
            TcpClient client = SocketFactory.CreateClient<TcpClient>(Url, servicePort); 
            TcpOpenAllPortDto tcp = new TcpOpenAllPortDto()
            {
                CMD = 5,
                DEVICE = device,
                SEQ = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
                PORT = 255
            }; 
            //发送
            client.Stream.ToPipeStream().WriteLine(JsonConvert.SerializeObject(tcp));
            client.Stream.Flush();

            client.DisConnect();
            client.Dispose();
            for (int i = 0; i < 20; i++)
            {
                Thread.Sleep(1000);
                var rdskey = tcp.DEVICE + tcp.CMD + tcp.SEQ;
                var RdsResult = redis.StringGet(rdskey);
                if (!string.IsNullOrEmpty(RdsResult))
                {
                    return JsonConvert.DeserializeObject<TcpOpenAllPortReturnDto>(RdsResult);
                }
            }

            return null;
        }

        /// <summary>
        /// 查看指定端口充电宝
        /// </summary>
        /// <param name="device"></param>
        /// <returns></returns>
        public TcpSeePortSnReturnDto SeePortSn(string device,int Port)
        {
            TcpClient client = SocketFactory.CreateClient<TcpClient>(Url, servicePort);

            TcpSeePortSnDto tcp = new TcpSeePortSnDto()
            {
                CMD = 6,
                DEVICE = device,
                PORT = Port,
                SEQ = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
            };
            //发送   //发送
            client.Stream.ToPipeStream().WriteLine(JsonConvert.SerializeObject(tcp));
            client.Stream.Flush();

            client.DisConnect();
            client.Dispose();
            for (int i = 0; i < 20; i++)
            {
                Thread.Sleep(1000);
                var rdskey = tcp.DEVICE + tcp.CMD + tcp.SEQ;
                var RdsResult = redis.StringGet(rdskey);
                if (!string.IsNullOrEmpty(RdsResult))
                {
                    return JsonConvert.DeserializeObject<TcpSeePortSnReturnDto>(RdsResult);
                }
            }

            return null;
        }

        public TcpSeeAllSnReturnDto SeeAllPortSn(string device)
        { 
            TcpClient client = SocketFactory.CreateClient<TcpClient>(Url, servicePort);
            //设置编码格式，默认是UTF8 

            TcpSeeAllSnDto tcp = new TcpSeeAllSnDto()
            {
                CMD = 6,
                DEVICE = device,
                SEQ = DateTime.Now.ToString("yyyyMMddHHmmssfff"),
                PORT = 255
            };
            //发送心跳 
            client.Stream.ToPipeStream().WriteLine(JsonConvert.SerializeObject(tcp));
            client.Stream.Flush();
            client.DisConnect();
            client.Dispose();
            //
            for (int i = 0; i < 20; i++)
            {
                Thread.Sleep(1000);
                var rdskey = tcp.DEVICE + tcp.CMD + tcp.SEQ;
                var RdsResult = redis.StringGet(rdskey);
                if (!string.IsNullOrEmpty(RdsResult))
                {
                    return JsonConvert.DeserializeObject<TcpSeeAllSnReturnDto>(RdsResult);
                }
            }

            return null;
        }
         

         
    }
}

参考：https://www.cnblogs.com/e4ky/p/12487542.html

posted @ 2024-12-03 16:57 天才卧龙阅读(41) 评论(0) 收藏举报

刷新页面返回顶部

天才第一步，雀氏纸尿布

代码改变世界，努力吧！

NetCore3.1 TCP服务之BeetleX

公告