完善TcpClient方式与产线设备交互、托盘下线的轮询和Debug测试逻辑

kazelee

2025-06-25 3daf4392ed4b720d67067180c51d986cef806bbe

完善TcpClient方式与产线设备交互、托盘下线的轮询和Debug测试逻辑

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/140a3f27-91f0-4f76-83cb-8a8da5896f2a.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/51f15dd6-39b1-4e8d-8d5a-7cdebd5ca9d8.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/754396c7-eaff-48c1-966a-0bbb85008292.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/7b233932-2148-476d-a58f-024f6cac6202.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/c349b9a0-3c00-4a74-bcf5-5ba46f79eacb.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/d454431d-5ff0-4870-b58b-659457d9dd0a.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/f3ed8dde-3902-4d3f-824a-8f00db530827.vsidx

Binary files differ

 .vs/HH.WCS.Mobox3.DSZSH/FileContentIndex/f9a252f3-6694-4ab8-a204-0ccfbf239beb.vsidx

Binary files differ

 Program.cs

@@ -10,6 +10,7 @@

using Task = System.Threading.Tasks.Task;
using Monitor = HH.WCS.Mobox3.DSZSH.core.Monitor;
using System.Net.Sockets;

namespace HH.WCS.Mobox3.DSZSH {
    internal class Program
@@ -20,7 +21,7 @@
            // 1.0 开启api
            Startup();
            // 2.0 开启tcp
            StartTcp();
            //StartTcp();
            // 3.0 开启S7
            //StartS7();
            // 4.0 开启Modbus
@@ -28,6 +29,7 @@

            // TCP测试
            //TcpClientHelper.Link("127.0.0.1", 8550);
            Task.Run(() => { WCSCore.StartServer(); });

            // 5.0 开启线程
            var rc = HostFactory.Run(x => {
@@ -156,5 +158,7 @@
                return task;
            }
        }

        
    }
}

 api/DebugController.cs

@@ -222,117 +222,7 @@
        [HttpPost]
        [Route("AddInboundTask")]
        public string AddInboundTask(AddInboundTaskInfo model) {
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.T托盘_满托下线入库;
            const string startAreaName = AreaName.B包装区;
            const string endAreaName = AreaName.M满托货架区;
            const string cntrType = "托盘";

            try {
                var cntrCode = model.CntrCode;
                var startLocCode = model.StartLoc;

                var startLoc = db.Queryable<TN_Location>()
                    .Where(l => l.S_CODE == startLocCode)
                    .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    .Where(l => l.N_CURRENT_NUM == 0) // 绑定前
                    .First();

                if (startLoc == null) {
                    info = $"在'{startAreaName}'中没有找到起点货位'{startLocCode}'，或不满足要求：未上锁、当前容器数量=0";
                    LogHelper.Info(info);
                    return info;
                }

                var locCntrRelOld = db.Queryable<TN_Loc_Container>()
                    .Where(c => c.S_CNTR_CODE == cntrCode).First();

                // 绑定货位和容器号
                var locCntrRel = new TN_Loc_Container {
                    S_LOC_CODE = startLocCode,
                    S_CNTR_CODE = cntrCode,
                    S_CNTR_TYPE = cntrType,
                };

                startLoc.N_CURRENT_NUM = 1; // 绑定后

                var endLoc = db.Queryable<TN_Location>()
                    .Where(a => Settings.AreaMap[endAreaName].Contains(a.S_AREA_CODE))
                    .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y") // 筛选：未上锁
                    .Where(a => a.N_CURRENT_NUM == 0) // 筛选：空货位
                    .OrderBy(l => l.N_LAYER)
                    .First();

                if (endLoc == null) {
                    info = $"在终点货区'{endAreaName}'中，没有找到合适的【终点货位】，需要满足要求：未上锁、当前容器数量=0";
                    LogHelper.Info(info);
                    return info;
                }

                var cntId = locCntrRel.S_CNTR_CODE;
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntId, taskName);

                LocationHelper.LockStartLoc(ref startLoc); // 起点出库锁
                LocationHelper.LockEndLoc(ref endLoc); // 终点入库锁

                using (var tran = db.Ado.UseTran()) {
                    if (locCntrRelOld != null) {
                        if (db.Deleteable<TN_Loc_Container>(locCntrRelOld).ExecuteCommand() <= 0 &&
                            db.Updateable<TN_Location>().SetColumns(l => l.N_CURRENT_NUM == 0).Where(l => l.S_CODE == locCntrRelOld.S_LOC_CODE).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            info = $"删除旧货位容器关系表失败：货位编码{locCntrRelOld.S_LOC_CODE}，容器编码{locCntrRelOld.S_CNTR_CODE}";
                            LogHelper.Info(info);
                            return info;
                        }
                    }

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"插入货位容器关系表失败：货位编码{locCntrRel.S_LOC_CODE}，容器编码{locCntrRel.S_CNTR_CODE}";
                        LogHelper.Info(info);
                        return info;
                    }

                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE, it.S_LOCK_OP, it.T_MODIFY, it.N_CURRENT_NUM }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败：更新起点货位{startLoc.S_CODE}锁状态失败";
                        LogHelper.Info(info);
                        return info;
                    }

                    if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE,
                        it.S_LOCK_STATE,
                        it.S_LOCK_OP,
                        it.T_MODIFY
                    }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败：更新终点货位{endLoc.S_CODE}锁状态失败";
                        LogHelper.Info(info);
                        return info;
                    }

                    if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败，容器号{cntId}，起点{startLoc.S_CODE}，终点货架{endLoc.S_CODE}";
                        LogHelper.Info(info);
                        return info;
                    }

                    tran.CommitTran();
                    info = $"生成任务'{taskName}'成功，容器号{cntId}，起点{startLoc.S_CODE}，终点货架{endLoc.S_CODE}";
                    LogHelper.Info(info);
                    return info;
                }

            }
            catch (Exception ex) {
                LogHelper.InfoEx(ex);
                return ex.Message;
            }
            return WCSCore.CreateInboundTask(model.StartLoc, model.CntrCode).Content;
        }

        /// <summary>

 core/Monitor.cs

@@ -24,11 +24,6 @@
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.T托盘_满托下线入库;
            const string startAreaName = AreaName.B包装区;
            const string endAreaName = AreaName.M满托货架区;
            const string cntrType = "托盘";

            try {
                // 查产线是否有物料信息
                foreach (var prod in Settings.ProductionLines) {
@@ -65,103 +60,7 @@
                    var startLocCode = prod.OffLoc[0]; // 用于测试
                    //var startLocCode = "CX01"; // 用于测试

                    var startLoc = db.Queryable<TN_Location>()
                    .Where(l => l.S_CODE == startLocCode)
                    .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE))
                    .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                    //.Where(l => l.N_CURRENT_NUM == 0) // 绑定前
                    .First();

                    if (startLoc == null) {
                        info = $"在'{startAreaName}'中没有找到起点货位'{startLocCode}'，或不满足要求：未上锁、当前容器数量=0";
                        LogHelper.Info(info);
                    }

                    var locCntrRelOld = db.Queryable<TN_Loc_Container>()
                        .Where(c => c.S_CNTR_CODE == cntrCode).First();

                    // 绑定货位和容器号
                    var locCntrRel = new TN_Loc_Container {
                        S_LOC_CODE = startLocCode,
                        S_CNTR_CODE = cntrCode,
                        S_CNTR_TYPE = cntrType,
                    };

                    startLoc.N_CURRENT_NUM = 1; // 绑定后

                    var endLoc = db.Queryable<TN_Location>()
                        .Where(a => Settings.AreaMap[endAreaName].Contains(a.S_AREA_CODE))
                        .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y") // 筛选：未上锁
                        .Where(a => a.N_CURRENT_NUM == 0) // 筛选：空货位
                        .OrderBy(l => l.N_LAYER)
                        .First();

                    if (endLoc == null) {
                        info = $"在终点货区'{endAreaName}'中，没有找到合适的【终点货位】，需要满足要求：未上锁、当前容器数量=0";
                        LogHelper.Info(info);
                    }

                    var cntId = locCntrRel.S_CNTR_CODE;
                    var task = WCSHelper.BuildTask(startLoc, endLoc, cntId, taskName);

                    LocationHelper.LockStartLoc(ref startLoc); // 起点出库锁
                    LocationHelper.LockEndLoc(ref endLoc); // 终点入库锁

                    using (var tran = db.Ado.UseTran()) {
                        if (locCntrRelOld != null) {
                            if (db.Deleteable<TN_Loc_Container>(locCntrRelOld).ExecuteCommand() <= 0 &&
                                db.Updateable<TN_Location>().SetColumns(l => l.N_CURRENT_NUM == 0).Where(l => l.S_CODE == locCntrRelOld.S_LOC_CODE).ExecuteCommand() <= 0) {
                                tran.RollbackTran();
                                info = $"删除旧货位容器关系表失败：货位编码{locCntrRelOld.S_LOC_CODE}，容器编码{locCntrRelOld.S_CNTR_CODE}";
                                LogHelper.Info(info);
                                continue;
                            }
                        }

                        if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            info = $"插入货位容器关系表失败：货位编码{locCntrRel.S_LOC_CODE}，容器编码{locCntrRel.S_CNTR_CODE}";
                            LogHelper.Info(info);
                            continue;
                        }

                        if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
                            it.N_LOCK_STATE,
                            it.S_LOCK_STATE,
                            it.S_LOCK_OP,
                            it.T_MODIFY,
                            it.N_CURRENT_NUM, // 起点货位绑定后，将货位状态更新
                        }).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            info = $"生成任务'{taskName}'失败：更新起点货位{startLoc.S_CODE}锁状态失败";
                            LogHelper.Info(info);
                            continue;
                        }

                        if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
                            it.N_LOCK_STATE,
                            it.S_LOCK_STATE,
                            it.S_LOCK_OP,
                            it.T_MODIFY,
                        }).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            info = $"生成任务'{taskName}'失败：更新终点货位{endLoc.S_CODE}锁状态失败";
                            LogHelper.Info(info);
                            continue;
                        }

                        if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            info = $"生成任务'{taskName}'失败，任务号={task.S_CODE}，容器号={cntId}，起点={startLoc.S_CODE}，终点={endLoc.S_CODE}";
                            LogHelper.Info(info);
                            continue;
                        }

                        tran.CommitTran();
                        info = $"生成任务'{taskName}'成功，任务号={task.S_CODE}，容器号={cntId}，起点={startLoc.S_CODE}，终点={endLoc.S_CODE}";
                        LogHelper.Info(info);
                        continue;
                    }
                    WCSCore.CreateInboundTask(startLocCode, cntrCode);
                }

            }

 core/WCSCore.cs

@@ -1,6 +1,8 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;

@@ -12,6 +14,8 @@
using HH.WCS.Mobox3.DSZSH.wms;

using Newtonsoft.Json;

using Swashbuckle.Swagger;

using static HH.WCS.Mobox3.DSZSH.api.ApiModel;

@@ -449,5 +453,204 @@
                LogHelper.Info("暂无任务");
            }
        }

        // TCP 非轮询方式 模拟产线下线的尝试

        public static void StartServer() {
            var ListenPort = 6000;
            TcpListener listener = new TcpListener(IPAddress.Any, ListenPort);
            listener.Start();
            Console.WriteLine($"后台服务已启动，监听端口 {ListenPort}...");

            while (true) {
                try {
                    // 接受产线连接
                    System.Net.Sockets.TcpClient client = listener.AcceptTcpClient();
                    Console.WriteLine($"产线客户端已连接: {client.Client.RemoteEndPoint}");

                    // 处理客户端请求（使用Task避免阻塞主线程）
                    Task.Run(() => HandleClientRequest(client));
                }
                catch (Exception ex) {
                    Console.WriteLine($"服务端异常: {ex.Message}");
                }
            }
        }

        public static void HandleClientRequest(System.Net.Sockets.TcpClient client) {
            var db = new SqlHelper<object>().GetInstance();
            using (client)
            using (NetworkStream stream = client.GetStream()) {
                try {
                    // 读取产线消息
                    byte[] buffer = new byte[1024];
                    int bytesRead = stream.Read(buffer, 0, buffer.Length);
                    string jsonMessage = Encoding.UTF8.GetString(buffer, 0, bytesRead);

                    // 解析消息
                    var message = JsonConvert.DeserializeObject<ProductCompletedMessage>(jsonMessage);
                    //Console.WriteLine($"收到产品完成通知 - 物料：{message.ItemCode}；批次号：{message.BatchNo}；容器号：{message.CntrCode}");
                    LogHelper.Info($"收到产品下线通知："+message);

                    string startLocCode = "";

                    // A. 如果是单个产线PLC，通过TCP传播，需要传递产线ID，根据ID计算起点货位
                    //startLocCode = Settings.ProductionLines[message.Id].OffLoc[0]; // 理论上应该只有1个OffLoc，否则应该注明是哪一个
                    
                    // B. 如果是每条产线各一个客户端，更简单，直接根据IP地址确定终点货位
                    // TODO 具体逻辑待后续确定时补完

                    var success = CreateInboundTask(startLocCode, message.CntrCode).Value;

                    // 发送响应
                    string response = success ? "ACK: 机器人已调度" : "NAK: 调度失败";
                    byte[] responseData = Encoding.UTF8.GetBytes(response);
                    stream.Write(responseData, 0, responseData.Length);
                }
                catch (Exception ex) {
                    Console.WriteLine($"处理客户端请求异常: {ex.Message}");
                }
            }
        }

        /// <summary>
        /// 入库作业创建只接收起点货位和容器号（物料信息待定、通过产线号计算起点的逻辑放在方法外）
        /// </summary>
        /// <param name="startLocCode"></param>
        /// <param name="cntrCode"></param>
        /// <returns></returns>
        public static Result<bool> CreateInboundTask(string startLocCode, string cntrCode) {
            var db = new SqlHelper<object>().GetInstance();
            var info = "";

            const string taskName = TaskName.T托盘_满托下线入库;
            const string startAreaName = AreaName.B包装区;
            const string endAreaName = AreaName.M满托货架区;
            const string cntrType = "托盘";

            try {
                var startLoc = db.Queryable<TN_Location>()
                .Where(l => l.S_CODE == startLocCode)
                .Where(l => Settings.AreaMap[startAreaName].Contains(l.S_AREA_CODE))
                .Where(l => l.N_LOCK_STATE == 0 && l.S_LOCK_STATE == "无" && l.C_ENABLE == "Y")
                //.Where(l => l.N_CURRENT_NUM == 0) // 绑定前
                .First();

                if (startLoc == null) {
                    info = $"在'{startAreaName}'中没有找到起点货位'{startLocCode}'，或不满足要求：未上锁、当前容器数量=0";
                    LogHelper.Info(info);
                    return new Result<bool>(false, info);
                }

                var locCntrRelOld = db.Queryable<TN_Loc_Container>()
                    .Where(c => c.S_CNTR_CODE == cntrCode).First();

                // 绑定货位和容器号
                var locCntrRel = new TN_Loc_Container {
                    S_LOC_CODE = startLocCode,
                    S_CNTR_CODE = cntrCode,
                    S_CNTR_TYPE = cntrType,
                };

                startLoc.N_CURRENT_NUM = 1; // 绑定后

                var endLoc = db.Queryable<TN_Location>()
                    .Where(a => Settings.AreaMap[endAreaName].Contains(a.S_AREA_CODE))
                    .Where(a => a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无" && a.C_ENABLE == "Y") // 筛选：未上锁
                    .Where(a => a.N_CURRENT_NUM == 0) // 筛选：空货位
                    .OrderBy(l => l.N_LAYER)
                    .First();

                if (endLoc == null) {
                    info = $"在终点货区'{endAreaName}'中，没有找到合适的【终点货位】，需要满足要求：未上锁、当前容器数量=0";
                    LogHelper.Info(info);
                    return new Result<bool>(false, info);
                }

                var cntId = locCntrRel.S_CNTR_CODE;
                var task = WCSHelper.BuildTask(startLoc, endLoc, cntId, taskName);

                LocationHelper.LockStartLoc(ref startLoc); // 起点出库锁
                LocationHelper.LockEndLoc(ref endLoc); // 终点入库锁

                using (var tran = db.Ado.UseTran()) {
                    if (locCntrRelOld != null) {
                        if (db.Deleteable<TN_Loc_Container>(locCntrRelOld).ExecuteCommand() <= 0 &&
                            db.Updateable<TN_Location>().SetColumns(l => l.N_CURRENT_NUM == 0).Where(l => l.S_CODE == locCntrRelOld.S_LOC_CODE).ExecuteCommand() <= 0) {
                            tran.RollbackTran();
                            info = $"删除旧货位容器关系表失败：货位编码{locCntrRelOld.S_LOC_CODE}，容器编码{locCntrRelOld.S_CNTR_CODE}";
                            LogHelper.Info(info);
                            return new Result<bool>(false, info);
                        }
                    }

                    if (db.Insertable<TN_Loc_Container>(locCntrRel).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"插入货位容器关系表失败：货位编码{locCntrRel.S_LOC_CODE}，容器编码{locCntrRel.S_CNTR_CODE}";
                        LogHelper.Info(info);
                        return new Result<bool>(false, info);
                    }

                    if (db.Updateable<TN_Location>(startLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE,
                        it.S_LOCK_STATE,
                        it.S_LOCK_OP,
                        it.T_MODIFY,
                        it.N_CURRENT_NUM, // 起点货位绑定后，将货位状态更新
                    }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败：更新起点货位{startLoc.S_CODE}锁状态失败";
                        LogHelper.Info(info);
                        return new Result<bool>(false, info);
                    }

                    if (db.Updateable<TN_Location>(endLoc).UpdateColumns(it => new {
                        it.N_LOCK_STATE,
                        it.S_LOCK_STATE,
                        it.S_LOCK_OP,
                        it.T_MODIFY,
                    }).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败：更新终点货位{endLoc.S_CODE}锁状态失败";
                        LogHelper.Info(info);
                        return new Result<bool>(false, info);
                    }

                    if (db.Insertable<TN_Task>(task).ExecuteCommand() <= 0) {
                        tran.RollbackTran();
                        info = $"生成任务'{taskName}'失败，任务号={task.S_CODE}，容器号={cntId}，起点={startLoc.S_CODE}，终点={endLoc.S_CODE}";
                        LogHelper.Info(info);
                        return new Result<bool>(false, info);
                    }

                    tran.CommitTran();
                    info = $"生成任务'{taskName}'成功，任务号={task.S_CODE}，容器号={cntId}，起点={startLoc.S_CODE}，终点={endLoc.S_CODE}";
                    LogHelper.Info(info);
                    return new Result<bool>(true, info);
                }
            }
            catch (Exception ex) {
                LogHelper.InfoEx(ex);
                return new Result<bool>(false, ex.Message);
            }
        }

    }

    public class ProductCompletedMessage {
        public int Id { get; set; }
        //public string ItemCode { get; set; }
        //public string BatchNo { get; set; }
        public string CntrCode { get; set; }
    }

    public class Result<T> {
        public T Value { get; set; }
        public string Content { get; set; }

        public Result(T value, string content) { 
            Value = value;
            Content = content;
        }
    }
}

 device/ModbusFactory.cs

@@ -8,6 +8,7 @@
using System.Linq;

using TcpClient = System.Net.Sockets.TcpClient;
using System.IO;

namespace HH.WCS.Mobox3.DSZSH.device {
    // 定义Modbus通讯接口
@@ -48,13 +49,31 @@
        /// <returns></returns>
        int[] ReadInputRegisters(int startingAddress, int quantity);
        /// <summary>
        /// 
        /// 写入单个线圈
        /// </summary>
        /// <param name="coilAddress"></param>
        /// <param name="value"></param>
        bool WriteSingleCoil(int coilAddress, bool value);
        /// <summary>
        /// 写入单个寄存器数据
        /// </summary>
        /// <param name="registerAddress"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        bool WriteSingleRegister(int registerAddress, ushort value);
        /// <summary>
        /// 写入多个线圈
        /// </summary>
        /// <param name="startingAddress"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        bool WriteMultipleCoils(int startingAddress, bool[] values);
        /// <summary>
        /// 写入多个寄存器数据
        /// </summary>
        /// <param name="startingAddress"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        bool WriteMultipleRegisters(int startingAddress, int[] values);
    }

@@ -80,7 +99,15 @@
        }

        static void Test() {
            try {
            var communicator = ModbusFactory.CreateCommunicator(ModbusCommunicationType.TcpSocket);

                communicator.Link("127.0.0.1", 502);
                var read = communicator.ReadInputRegisters(0, 5);
            }
            catch (Exception ex) {
                LogHelper.InfoEx(ex);
            }
        }
    }

@@ -134,16 +161,19 @@

        public bool[] ReadCoils(int startingAddress, int quantity) {
            bool[] res = new bool[0];
            var client = _modbusClient;
            if (_modbusClient != null && IsConnected) {
                var ip = client.IPAddress;
                var port = client.Port;
                try {
                    res = _modbusClient.ReadCoils(startingAddress, quantity);
                    if (res.Length != 0) {
                        //读取成功
                        LogHelper.Info($"读取成功：ReadCoils");
                        LogHelper.Info($"读取成功：ReadCoils:IP:{ip},Port:{port}");
                    }
                    else {
                        //读取失败
                        LogHelper.Info($"读取失败：ReadCoils");
                        LogHelper.Info($"读取失败：ReadCoils:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
@@ -151,23 +181,26 @@
                }
            }
            else {
                LogHelper.Info($"设备未连接，读取失败：ReadCoils");
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }

        public bool[] ReadDiscreteInputs(int startingAddress, int quantity) {
            bool[] res = new bool[0];
            var client = _modbusClient;
            if (_modbusClient != null && IsConnected) {
                var ip = client.IPAddress;
                var port = client.Port;
                try {
                    res = _modbusClient.ReadDiscreteInputs(startingAddress, quantity);
                    if (res.Length != 0) {
                        //读取成功
                        LogHelper.Info($"读取成功：ReadDiscreteInputs");
                        LogHelper.Info($"读取成功：ReadDiscreteInputs:IP:{ip},Port:{port}");
                    }
                    else {
                        //读取失败
                        LogHelper.Info($"读取失败：ReadDiscreteInputs");
                        LogHelper.Info($"读取失败：ReadDiscreteInputs:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
@@ -175,7 +208,7 @@
                }
            }
            else {
                LogHelper.Info($"设备未连接，读取失败：ReadDiscreteInputs");
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }
@@ -183,26 +216,28 @@
        public int[] ReadHoldingRegisters(int startingAddress, int quantity) {
            int[] res = new int[0];
            var client = _modbusClient;
            if (client != null && client.Connected) {
            var ip = client.IPAddress;
            var port = client.Port;
            if (client != null && client.Connected) {
                try {
                    //一个寄存器是16位，返回2个int类型
                    res = client.ReadHoldingRegisters(startingAddress, quantity);
                    if (res.Length != 0) {
                        //读取成功
                        LogHelper.Info($"读取成功：ReadHoldingRegisters:IP:{ip},Port:{port}");
                    }
                    else {
                        //读取失败
                        LogHelper.Info($"读取失败：ReadHoldingRegisters:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
                    //如果请求数量超出保持寄存器的最大数据行数，会报错
                    LogHelper.Info($"发生了异常:{ex.Message},IP:{ip},Port:{port}", "Error");
                    LogHelper.InfoEx(ex);
                }
            }
            else {
                LogHelper.Info($"未找到Modbus设备实例对象:IP:{ip},Port:{port}");
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }
@@ -210,24 +245,26 @@
        public int[] ReadInputRegisters(int startingAddress, int quantity) {
            int[] res = new int[0];
            var client = _modbusClient;
            if (client != null && client.Connected) {
            var ip = client.IPAddress;
            var port = client.Port;
            if (client != null && client.Connected) {
                try {
                    res = client.ReadInputRegisters(startingAddress, quantity);
                    if (res.Length != 0) {
                        //读取成功
                        LogHelper.Info($"读取成功：ReadInputRegisters:IP:{ip},Port:{port}");
                    }
                    else {
                        //读取失败
                        LogHelper.Info($"读取失败：ReadInputRegisters:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {

                    LogHelper.InfoEx(ex);
                }
            }
            else {

                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }
@@ -235,25 +272,27 @@
        public bool WriteSingleCoil(int coilAddress, bool value) {
            var res = false;
            var client = _modbusClient;
            if (client != null && client.Connected) {
            var ip = client.IPAddress;
            var port = client.Port;
            if (client != null && client.Connected) {
                try {
                    client.WriteSingleCoil(coilAddress, value);
                    res = value == client.ReadCoils(coilAddress, 1)[0];
                    if (res) {
                        //写入成功
                        LogHelper.Info($"写入成功：WriteSingleCoil:IP:{ip},Port:{port}");
                    }
                    else {
                        //写入失败
                        LogHelper.Info($"写入失败：WriteSingleCoil:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {

                    LogHelper.InfoEx(ex);
                }
            }
            else {

                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }
@@ -261,25 +300,27 @@
        public bool WriteSingleRegister(int registerAddress, ushort value) {
            var res = false;
            var client = _modbusClient;
            if (client != null && client.Connected) {
            var ip = client.IPAddress;
            var port = client.Port;
            if (client != null && client.Connected) {
                try {
                    client.WriteSingleRegister(registerAddress, value);
                    res = value == client.ReadHoldingRegisters(registerAddress, 1)[0];
                    if (res) {
                        //写入成功
                        LogHelper.Info($"写入成功：WriteSingleRegister:IP:{ip},Port:{port}");
                    }
                    else {
                        //写入失败
                        LogHelper.Info($"写入失败：WriteSingleRegister:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {

                    LogHelper.InfoEx(ex);
                }
            }
            else {

                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }
@@ -287,26 +328,28 @@
        public bool WriteMultipleCoils(int startingAddress, bool[] values) {
            var res = false;
            var client = _modbusClient;
            if (client != null && client.Connected) {
            var ip = client.IPAddress;
            var port = client.Port;
            if (client != null && client.Connected) {
                try {
                    client.WriteMultipleCoils(startingAddress, values);
                    var dataRead = client.ReadCoils(startingAddress, values.Length);
                    res = values.SequenceEqual(dataRead);
                    if (res) {
                        //写入成功
                        LogHelper.Info($"写入成功：WriteMultipleCoils:IP:{ip},Port:{port}");
                    }
                    else {
                        //写入失败
                        LogHelper.Info($"写入失败：WriteMultipleCoils:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {

                    LogHelper.InfoEx(ex);
                }
            }
            else {

                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }
@@ -314,33 +357,34 @@
        public bool WriteMultipleRegisters(int startingAddress, int[] values) {
            var res = false;
            var client = _modbusClient;
            if (client != null && client.Connected) {
            var ip = client.IPAddress;
            var port = client.Port;
            var log = string.Join(",", values.Select(x => x.ToString()));
            if (client != null && client.Connected) {
                try {
                    client.WriteMultipleRegisters(startingAddress, values);
                    var dataRead = client.ReadHoldingRegisters(startingAddress, values.Length);
                    res = values.SequenceEqual(dataRead);
                    if (res) {
                        LogHelper.Info($"写入成功,IP:{ip},Port:{port},{log}");
                        LogHelper.Info($"写入成功,WriteMultipleRegisters:IP:{ip},Port:{port},{log}");
                    }
                    else {
                        LogHelper.Info($"写入失败,IP:{ip},Port:{port},{log}");
                        LogHelper.Info($"写入失败,WriteMultipleRegisters:IP:{ip},Port:{port},{log}");
                    }
                }
                catch (Exception ex) {
                    LogHelper.Info($"发生了异常:{ex.Message},IP:{ip},Port:{port},{log}", "Error");
                    LogHelper.InfoEx(ex);
                }
            }
            else {
                LogHelper.Info($"未配置的设备信息,IP:{ip},Port:{port},{log}");
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
            }
            return res;
        }

        public void Dispose() {
            //_modbusClient?.Dispose();
            GC.SuppressFinalize(_modbusClient);
        }
    }

@@ -348,9 +392,10 @@
    public class TcpSocketCommunicator : IModbusCommunicator {
        private System.Net.Sockets.TcpClient _tcpClient;
        private NetworkStream _networkStream;
        private byte unitIdentifier = 1; // 默认单元标识符

        //public bool IsConnected => _tcpClient?.Connected ?? false;
        public bool IsConnected { get { if (_tcpClient != null) { return true; } else { return false; } } }
        public bool IsConnected => _tcpClient?.Connected ?? false;
        //public bool IsConnected { get { if (_tcpClient != null) { return _tcpClient.Connected; } else { return false; } } }

        public void Link(string ipAddress, int port) {
            _tcpClient = new System.Net.Sockets.TcpClient();
@@ -372,50 +417,407 @@
            }
        }

        // 以下方法需要根据你的Modbus TCP协议具体实现
        public bool[] ReadCoils(int startingAddress, int quantity) {
            // 实现TCP方式读取线圈
            throw new NotImplementedException();
            if (quantity < 1 || quantity > 2000)
                throw new ArgumentException("Quantity must be between 1 and 2000");

            // 构建请求报文（12字节）
            byte[] request = new byte[12];
            request[0] = 0x00; // 事务ID高字节
            request[1] = 0x01; // 事务ID低字节（示例值）
            request[2] = 0x00; // 协议ID高字节（固定0）
            request[3] = 0x00; // 协议ID低字节（固定0）
            request[4] = 0x00; // 长度高字节（后续6字节）
            request[5] = 0x06; // 长度低字节
            request[6] = unitIdentifier; // 单元标识符
            request[7] = 0x01; // 功能码（读线圈）
            request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
            request[9] = (byte)startingAddress; // 起始地址低字节
            request[10] = (byte)(quantity >> 8); // 数量高字节
            request[11] = (byte)quantity; // 数量低字节

            // 发送请求
            _networkStream.Write(request, 0, request.Length);

            // 读取响应头（8字节）
            byte[] responseHeader = new byte[8];
            int bytesRead = _networkStream.Read(responseHeader, 0, 8);
            if (bytesRead != 8)
                throw new Exception("Invalid response header length");

            // 校验事务ID、协议ID、单元标识符
            if (responseHeader[0] != request[0] || responseHeader[1] != request[1] ||
                responseHeader[2] != 0x00 || responseHeader[3] != 0x00 ||
                responseHeader[6] != unitIdentifier)
                throw new Exception("Invalid response header");

            // 检查异常响应（功能码 + 0x80）
            if (responseHeader[7] == 0x81) {
                int errorCode = _networkStream.ReadByte();
                throw new Exception($"Modbus error. Code: {errorCode}");
            }
            else if (responseHeader[7] != 0x01)
                throw new Exception("Invalid function code in response");

            // 读取数据部分（字节数 + 实际数据）
            byte byteCount = responseHeader[8];
            byte[] responseData = new byte[byteCount];
            bytesRead = _networkStream.Read(responseData, 0, byteCount);
            if (bytesRead != byteCount)
                throw new Exception("Invalid response data length");

            // 解析线圈状态（每个位表示一个线圈）
            bool[] coils = new bool[quantity];
            for (int i = 0; i < quantity; i++) {
                int byteIndex = i / 8;
                int bitIndex = i % 8;
                coils[i] = (responseData[byteIndex] & (1 << bitIndex)) != 0;
            }

            return coils;
        }

        public bool[] ReadDiscreteInputs(int startingAddress, int quantity) {
            // 实现TCP方式读取离散输入
            throw new NotImplementedException();
            // 报文结构与ReadCoils几乎相同，仅功能码改为0x02
            byte[] request = new byte[12];
            request[0] = 0x00; // 事务ID高字节
            request[1] = 0x01; // 事务ID低字节（示例值）
            request[2] = 0x00; // 协议ID高字节（固定0）
            request[3] = 0x00; // 协议ID低字节（固定0）
            request[4] = 0x00; // 长度高字节（后续6字节）
            request[5] = 0x06; // 长度低字节
            request[6] = unitIdentifier;
            request[7] = 0x02; // 功能码：读离散输入
            request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
            request[9] = (byte)startingAddress; // 起始地址低字节
            request[10] = (byte)(quantity >> 8); // 数量高字节
            request[11] = (byte)quantity; // 数量低字节

            _networkStream.Write(request, 0, request.Length);

            // 响应处理逻辑与ReadCoils一致
            byte[] responseHeader = new byte[8];
            _networkStream.Read(responseHeader, 0, 8);

            // 校验和异常处理（参考ReadCoils）
            if (responseHeader[7] == 0x82) // 异常响应
            {
                int errorCode = _networkStream.ReadByte();
                throw new Exception($"Modbus error. Code: {errorCode}");
            }

            byte byteCount = responseHeader[8];
            byte[] responseData = new byte[byteCount];
            _networkStream.Read(responseData, 0, byteCount);

            // 解析离散输入状态
            bool[] inputs = new bool[quantity];
            for (int i = 0; i < quantity; i++) {
                int byteIndex = i / 8;
                int bitIndex = i % 8;
                inputs[i] = (responseData[byteIndex] & (1 << bitIndex)) != 0;
            }

            return inputs;
        }

        public int[] ReadHoldingRegisters(int startingAddress, int quantity) {
            // 实现TCP方式读取保持寄存器
            throw new NotImplementedException();
            if (quantity < 1 || quantity > 125)
                throw new ArgumentException("Quantity must be between 1 and 125");

            // 构建请求报文（12字节）
            byte[] request = new byte[12];
            request[0] = 0x00; // 事务ID高字节（示例值）
            request[1] = 0x01; // 事务ID低字节
            request[2] = 0x00; // 协议ID高字节（固定0）
            request[3] = 0x00; // 协议ID低字节（固定0）
            request[4] = 0x00; // 长度高字节（后续6字节）
            request[5] = 0x06; // 长度低字节
            request[6] = unitIdentifier; // 单元标识符
            request[7] = 0x03; // 功能码（读保持寄存器）
            request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
            request[9] = (byte)startingAddress; // 起始地址低字节
            request[10] = (byte)(quantity >> 8); // 数量高字节
            request[11] = (byte)quantity; // 数量低字节

            // 发送请求
            _networkStream.Write(request, 0, request.Length);

            // 读取响应头（8字节）
            byte[] responseHeader = new byte[8];
            int bytesRead = _networkStream.Read(responseHeader, 0, 8);
            if (bytesRead != 8)
                throw new Exception("Invalid response header length");

            // 校验事务ID、协议ID、单元标识符
            if (responseHeader[0] != request[0] || responseHeader[1] != request[1] ||
                responseHeader[2] != 0x00 || responseHeader[3] != 0x00 ||
                responseHeader[6] != unitIdentifier)
                throw new Exception("Invalid response header");

            // 检查异常响应（功能码 + 0x80）
            if (responseHeader[7] == 0x83) {
                int errorCode = _networkStream.ReadByte();
                throw new Exception($"Modbus error. Code: {errorCode}");
            }
            else if (responseHeader[7] != 0x03)
                throw new Exception("Invalid function code in response");

            // 读取数据部分（字节数 + 实际数据）
            byte byteCount = responseHeader[8];
            byte[] responseData = new byte[byteCount];
            bytesRead = _networkStream.Read(responseData, 0, byteCount);
            if (bytesRead != byteCount)
                throw new Exception("Invalid response data length");

            // 解析寄存器值（大端序）
            int[] registers = new int[quantity];
            for (int i = 0; i < quantity; i++) {
                int offset = i * 2;
                registers[i] = (ushort)((responseData[offset] << 8) | responseData[offset + 1]);
            }

            return registers;
        }

        public int[] ReadInputRegisters(int startingAddress, int quantity) {
            // 实现TCP方式读取输入寄存器
            throw new NotImplementedException();
            if (quantity < 1 || quantity > 125)
                throw new ArgumentException("Quantity must be between 1 and 125");

            // 构建Modbus TCP请求报文
            byte[] request = new byte[12];

            // 事务标识符（可以简单递增）
            request[0] = 0x00;
            request[1] = 0x01;

            // 协议标识符（Modbus固定为0）
            request[2] = 0x00;
            request[3] = 0x00;

            // 长度字段（后面还有6字节）
            request[4] = 0x00;
            request[5] = 0x06;

            // 单元标识符
            request[6] = unitIdentifier;

            // 功能码（4表示读输入寄存器）
            request[7] = 0x04;

            // 起始地址
            request[8] = (byte)(startingAddress >> 8);
            request[9] = (byte)startingAddress;

            // 寄存器数量
            request[10] = (byte)(quantity >> 8);
            request[11] = (byte)quantity;

            // 发送请求
            _networkStream.Write(request, 0, request.Length);

            // 接收响应
            byte[] responseHeader = new byte[8];
            int bytesRead = _networkStream.Read(responseHeader, 0, 8);

            if (bytesRead != 8)
                throw new Exception("Invalid response header length");

            // 检查事务ID和协议ID是否匹配
            if (responseHeader[0] != request[0] || responseHeader[1] != request[1] ||
                responseHeader[2] != 0x00 || responseHeader[3] != 0x00)
                throw new Exception("Invalid response header");

            // 检查单元标识符和功能码
            if (responseHeader[6] != unitIdentifier)
                throw new Exception("Unit identifier mismatch");

            if (responseHeader[7] != 0x04 && responseHeader[7] != 0x84)
                throw new Exception("Invalid function code in response");

            // 检查异常响应
            if (responseHeader[7] == 0x84) {
                byte errorCode = responseHeader[8];
                throw new Exception($"Modbus error response. Error code: {errorCode}");
        }

        public bool WriteSingleCoil(int coilAddress, bool value) {
            // 实现TCP方式写入单个线圈
            throw new NotImplementedException();
            // 读取剩余响应数据
            byte byteCount = responseHeader[8];
            byte[] responseData = new byte[byteCount];
            bytesRead = _networkStream.Read(responseData, 0, byteCount);

            if (bytesRead != byteCount)
                throw new Exception("Invalid response data length");

            // 解析寄存器值
            int[] registers = new int[quantity];
            for (int i = 0; i < quantity; i++) {
                int offset = i * 2;
                registers[i] = (ushort)((responseData[offset] << 8) | responseData[offset + 1]);
        }

        public bool WriteSingleRegister(int registerAddress, ushort value) {
            // 实现TCP方式写入单个寄存器
            throw new NotImplementedException();
            return registers;
        }

        public bool WriteSingleCoil(int address, bool value) {
            // 请求报文固定长度12字节
            byte[] request = new byte[12];
            request[0] = 0x00; // 事务ID
            request[1] = 0x01;
            request[2] = 0x00; // 协议ID
            request[3] = 0x00;
            request[4] = 0x00; // 长度
            request[5] = 0x06;
            request[6] = unitIdentifier;
            request[7] = 0x05; // 功能码
            request[8] = (byte)(address >> 8); // 地址高字节
            request[9] = (byte)address; // 地址低字节
            request[10] = (byte)(value ? 0xFF : 0x00); // ON=0xFF00, OFF=0x0000
            request[11] = 0x00;

            _networkStream.Write(request, 0, request.Length);

            // 响应应与请求完全一致（回显）
            byte[] response = new byte[12];
            int bytesRead = _networkStream.Read(response, 0, 12);
            if (bytesRead != 12)
                throw new Exception("Invalid response length");

            // 校验回显报文
            for (int i = 0; i < 12; i++) {
                if (response[i] != request[i])
                    throw new Exception("Response does not match request");
            }
            return true;
        }

        public bool WriteSingleRegister(int address, ushort value) {
            byte[] request = new byte[12];
            request[0] = 0x00; // 事务ID
            request[1] = 0x01;
            request[2] = 0x00; // 协议ID
            request[3] = 0x00;
            request[4] = 0x00; // 长度
            request[5] = 0x06;
            request[6] = unitIdentifier;
            request[7] = 0x06; // 功能码
            request[8] = (byte)(address >> 8); // 地址高字节
            request[9] = (byte)address;
            request[10] = (byte)(value >> 8); // 值高字节
            request[11] = (byte)value; // 值低字节

            _networkStream.Write(request, 0, request.Length);

            // 检查回显响应（同WriteSingleCoil）
            byte[] response = new byte[12];
            _networkStream.Read(response, 0, 12);
            if (!response.SequenceEqual(request))
                throw new Exception("Response mismatch");

            return true;
        }

        public bool WriteMultipleCoils(int startingAddress, bool[] values) {
            // 实现TCP方式写入多个线圈
            throw new NotImplementedException();
            int quantity = values.Length;
            if (quantity < 1 || quantity > 1968)
                throw new ArgumentException("Quantity must be between 1 and 1968");

            // 计算需要的字节数（每个字节存储8个线圈状态）
            int byteCount = (quantity + 7) / 8;
            byte[] coilBytes = new byte[byteCount];

            // 将bool数组压缩为字节数组
            for (int i = 0; i < quantity; i++) {
                if (values[i]) {
                    int byteIndex = i / 8;
                    int bitIndex = i % 8;
                    coilBytes[byteIndex] |= (byte)(1 << bitIndex);
                }
            }

            // 构建请求报文（13 + 线圈字节数）
            byte[] request = new byte[13 + coilBytes.Length];
            request[0] = 0x00; // 事务ID高字节
            request[1] = 0x01; // 事务ID低字节
            request[2] = 0x00; // 协议ID高字节
            request[3] = 0x00; // 协议ID低字节
            request[4] = (byte)((7 + coilBytes.Length) >> 8); // 长度高字节
            request[5] = (byte)(7 + coilBytes.Length); // 长度低字节
            request[6] = unitIdentifier;
            request[7] = 0x0F; // 功能码（写多个线圈）
            request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
            request[9] = (byte)startingAddress; // 起始地址低字节
            request[10] = (byte)(quantity >> 8); // 数量高字节
            request[11] = (byte)quantity; // 数量低字节
            request[12] = (byte)byteCount; // 字节数
            Buffer.BlockCopy(coilBytes, 0, request, 13, coilBytes.Length);

            // 发送请求
            _networkStream.Write(request, 0, request.Length);

            // 读取响应（固定12字节）
            byte[] response = new byte[12];
            int bytesRead = _networkStream.Read(response, 0, 12);
            if (bytesRead != 12)
                throw new Exception("Invalid response length");

            // 校验回显的地址和数量
            if (response[8] != request[8] || response[9] != request[9] ||
                response[10] != request[10] || response[11] != request[11])
                throw new Exception("Response address/quantity mismatch");

            return true;
        }

        public bool WriteMultipleRegisters(int startingAddress, int[] values) {
            // 实现TCP方式写入多个寄存器
            throw new NotImplementedException();
            int quantity = values.Length;
            if (quantity < 1 || quantity > 123)
                throw new ArgumentException("Quantity must be between 1 and 123");

            // 将ushort数组转换为字节数组（大端序）
            byte[] valueBytes = new byte[quantity * 2];
            for (int i = 0; i < quantity; i++) {
                valueBytes[i * 2] = (byte)(values[i] >> 8);
                valueBytes[i * 2 + 1] = (byte)values[i];
            }

            // 构建请求报文（13 + 值字节数）
            byte[] request = new byte[13 + valueBytes.Length];
            request[0] = 0x00; // 事务ID高字节
            request[1] = 0x01; // 事务ID低字节
            request[2] = 0x00; // 协议ID高字节
            request[3] = 0x00; // 协议ID低字节
            request[4] = (byte)((7 + valueBytes.Length) >> 8); // 长度高字节
            request[5] = (byte)(7 + valueBytes.Length); // 长度低字节
            request[6] = unitIdentifier;
            request[7] = 0x10; // 功能码（写多个寄存器）
            request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
            request[9] = (byte)startingAddress; // 起始地址低字节
            request[10] = (byte)(quantity >> 8); // 数量高字节
            request[11] = (byte)quantity; // 数量低字节
            request[12] = (byte)(quantity * 2); // 字节数
            Buffer.BlockCopy(valueBytes, 0, request, 13, valueBytes.Length);

            // 发送请求
            _networkStream.Write(request, 0, request.Length);

            // 读取响应（固定12字节）
            byte[] response = new byte[12];
            int bytesRead = _networkStream.Read(response, 0, 12);
            if (bytesRead != 12)
                throw new Exception("Invalid response length");

            // 校验回显的地址和数量
            if (response[8] != request[8] || response[9] != request[9] ||
                response[10] != request[10] || response[11] != request[11])
                throw new Exception("Response address/quantity mismatch");

            return true;
        }

        public void Dispose() {
            _networkStream?.Dispose();
            //_tcpClient?.Dispose();
            _tcpClient?.Dispose();
        }
    }
}