封装部分业务代码，继续优化日志打印流程

kazelee

16 小时以前 f8d23dcf8d6501482db1a5180325194232afe96c

 device/ModbusFactory.cs

@@ -21,28 +21,28 @@

        // 常用的Modbus功能码方法
        /// <summary>
        /// 读一个或多个线圈，返回一个bit真假数组
        /// 读一个或多个线圈,返回一个bit真假数组
        /// </summary>
        /// <param name="startingAddress"></param>
        /// <param name="quantity"></param>
        /// <returns></returns>
        bool[] ReadCoils(int startingAddress, int quantity);
        /// <summary>
        /// 读一个或多个离散输入，返回一个bit真假数组
        /// 读一个或多个离散输入,返回一个bit真假数组
        /// </summary>
        /// <param name="startingAddress"></param>
        /// <param name="quantity"></param>
        /// <returns></returns>
        bool[] ReadDiscreteInputs(int startingAddress, int quantity);
        /// <summary>
        /// 批量读取或单独读取保持寄存器，返回的是32位int数组
        /// 批量读取或单独读取保持寄存器,返回的是32位int数组
        /// </summary>
        /// <param name="startingAddress"></param>
        /// <param name="quantity"></param>
        /// <returns></returns>
        int[] ReadHoldingRegisters(int startingAddress, int quantity);
        /// <summary>
        /// 读一个或多个输入寄存器，返回一个int32位数组
        /// 读一个或多个输入寄存器,返回一个int32位数组
        /// </summary>
        /// <param name="startingAddress"></param>
        /// <param name="quantity"></param>
@@ -92,8 +92,8 @@
                case ModbusCommunicationType.TcpSocket:
                    return new TcpSocketCommunicator();
                default:
                    //throw new ArgumentException("不支持的Modbus通信方式：请选择EasyModbus或TcpSocket");
                    LogHelper.Info("不支持的Modbus通信方式：请选择EasyModbus或TcpSocket");
                    //throw new ArgumentException("不支持的Modbus通信方式:请选择EasyModbus或TcpSocket");
                    LogHelper.Info("不支持的Modbus通信方式:请选择EasyModbus或TcpSocket");
                    return null;
            }
        }
@@ -127,10 +127,10 @@
            _modbusClient.Connect();
            
            if (IsConnected) {
                LogHelper.Info($"连接成功：{ipAddress}:{port}");
                LogHelper.Info($"连接成功:{ipAddress}:{port}");
            }
            else {
                LogHelper.Info($"连接失败：{ipAddress}:{port}");
                LogHelper.Info($"连接失败:{ipAddress}:{port}");
            }
        }

@@ -143,10 +143,10 @@
            _modbusClient?.Disconnect();

            if (IsConnected) {
                LogHelper.Info($"连接成功：{_modbusClient.IPAddress}:{_modbusClient.Port}");
                LogHelper.Info($"连接成功:{_modbusClient.IPAddress}:{_modbusClient.Port}");
            }
            else {
                LogHelper.Info($"连接失败：{_modbusClient.IPAddress} : {_modbusClient.Port}");
                LogHelper.Info($"连接失败:{_modbusClient.IPAddress} : {_modbusClient.Port}");
            }
        }

@@ -169,11 +169,11 @@
                    res = _modbusClient.ReadCoils(startingAddress, quantity);
                    if (res.Length != 0) {
                        //读取成功
                        LogHelper.Info($"读取成功：ReadCoils:IP:{ip},Port:{port}");
                        LogHelper.Info($"读取成功:ReadCoils:IP:{ip},Port:{port}");
                    }
                    else {
                        //读取失败
                        LogHelper.Info($"读取失败：ReadCoils:IP:{ip},Port:{port}");
                        LogHelper.Info($"读取失败:ReadCoils:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
@@ -181,7 +181,7 @@
                }
            }
            else {
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
                LogHelper.Info($"未找到Modbus设备实例对象,或对象未成功连接");
            }
            return res;
        }
@@ -196,11 +196,11 @@
                    res = _modbusClient.ReadDiscreteInputs(startingAddress, quantity);
                    if (res.Length != 0) {
                        //读取成功
                        LogHelper.Info($"读取成功：ReadDiscreteInputs:IP:{ip},Port:{port}");
                        LogHelper.Info($"读取成功:ReadDiscreteInputs:IP:{ip},Port:{port}");
                    }
                    else {
                        //读取失败
                        LogHelper.Info($"读取失败：ReadDiscreteInputs:IP:{ip},Port:{port}");
                        LogHelper.Info($"读取失败:ReadDiscreteInputs:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
@@ -208,7 +208,7 @@
                }
            }
            else {
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
                LogHelper.Info($"未找到Modbus设备实例对象,或对象未成功连接");
            }
            return res;
        }
@@ -220,24 +220,24 @@
                var ip = client.IPAddress;
                var port = client.Port;
                try {
                    //一个寄存器是16位，返回2个int类型
                    //一个寄存器是16位,返回2个int类型
                    res = client.ReadHoldingRegisters(startingAddress, quantity);
                    if (res.Length != 0) {
                        //读取成功
                        LogHelper.Info($"读取成功：ReadHoldingRegisters:IP:{ip},Port:{port}");
                        LogHelper.Info($"读取成功:ReadHoldingRegisters:IP:{ip},Port:{port}");
                    }
                    else {
                        //读取失败
                        LogHelper.Info($"读取失败：ReadHoldingRegisters:IP:{ip},Port:{port}");
                        LogHelper.Info($"读取失败:ReadHoldingRegisters:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
                    //如果请求数量超出保持寄存器的最大数据行数，会报错
                    //如果请求数量超出保持寄存器的最大数据行数,会报错
                    LogHelper.InfoEx(ex);
                }
            }
            else {
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
                LogHelper.Info($"未找到Modbus设备实例对象,或对象未成功连接");
            }
            return res;
        }
@@ -252,11 +252,11 @@
                    res = client.ReadInputRegisters(startingAddress, quantity);
                    if (res.Length != 0) {
                        //读取成功
                        LogHelper.Info($"读取成功：ReadInputRegisters:IP:{ip},Port:{port}");
                        LogHelper.Info($"读取成功:ReadInputRegisters:IP:{ip},Port:{port}");
                    }
                    else {
                        //读取失败
                        LogHelper.Info($"读取失败：ReadInputRegisters:IP:{ip},Port:{port}");
                        LogHelper.Info($"读取失败:ReadInputRegisters:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
@@ -264,7 +264,7 @@
                }
            }
            else {
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
                LogHelper.Info($"未找到Modbus设备实例对象,或对象未成功连接");
            }
            return res;
        }
@@ -280,11 +280,11 @@
                    res = value == client.ReadCoils(coilAddress, 1)[0];
                    if (res) {
                        //写入成功
                        LogHelper.Info($"写入成功：WriteSingleCoil:IP:{ip},Port:{port}");
                        LogHelper.Info($"写入成功:WriteSingleCoil:IP:{ip},Port:{port}");
                    }
                    else {
                        //写入失败
                        LogHelper.Info($"写入失败：WriteSingleCoil:IP:{ip},Port:{port}");
                        LogHelper.Info($"写入失败:WriteSingleCoil:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
@@ -292,7 +292,7 @@
                }
            }
            else {
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
                LogHelper.Info($"未找到Modbus设备实例对象,或对象未成功连接");
            }
            return res;
        }
@@ -308,11 +308,11 @@
                    res = value == client.ReadHoldingRegisters(registerAddress, 1)[0];
                    if (res) {
                        //写入成功
                        LogHelper.Info($"写入成功：WriteSingleRegister:IP:{ip},Port:{port}");
                        LogHelper.Info($"写入成功:WriteSingleRegister:IP:{ip},Port:{port}");
                    }
                    else {
                        //写入失败
                        LogHelper.Info($"写入失败：WriteSingleRegister:IP:{ip},Port:{port}");
                        LogHelper.Info($"写入失败:WriteSingleRegister:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
@@ -320,7 +320,7 @@
                }
            }
            else {
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
                LogHelper.Info($"未找到Modbus设备实例对象,或对象未成功连接");
            }
            return res;
        }
@@ -337,11 +337,11 @@
                    res = values.SequenceEqual(dataRead);
                    if (res) {
                        //写入成功
                        LogHelper.Info($"写入成功：WriteMultipleCoils:IP:{ip},Port:{port}");
                        LogHelper.Info($"写入成功:WriteMultipleCoils:IP:{ip},Port:{port}");
                    }
                    else {
                        //写入失败
                        LogHelper.Info($"写入失败：WriteMultipleCoils:IP:{ip},Port:{port}");
                        LogHelper.Info($"写入失败:WriteMultipleCoils:IP:{ip},Port:{port}");
                    }
                }
                catch (Exception ex) {
@@ -349,7 +349,7 @@
                }
            }
            else {
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
                LogHelper.Info($"未找到Modbus设备实例对象,或对象未成功连接");
            }
            return res;
        }
@@ -377,7 +377,7 @@
                }
            }
            else {
                LogHelper.Info($"未找到Modbus设备实例对象，或对象未成功连接");
                LogHelper.Info($"未找到Modbus设备实例对象,或对象未成功连接");
            }
            return res;
        }
@@ -421,16 +421,16 @@
            if (quantity < 1 || quantity > 2000)
                throw new ArgumentException("Quantity must be between 1 and 2000");

            // 构建请求报文（12字节）
            // 构建请求报文 (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[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[7] = 0x01; // 功能码 (读线圈) 
            request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
            request[9] = (byte)startingAddress; // 起始地址低字节
            request[10] = (byte)(quantity >> 8); // 数量高字节
@@ -439,19 +439,19 @@
            // 发送请求
            _networkStream.Write(request, 0, request.Length);

            // 读取响应头（8字节）
            // 读取响应头 (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、单元标识符
            // 校验事务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）
            // 检查异常响应 (功能码 + 0x80) 
            if (responseHeader[7] == 0x81) {
                int errorCode = _networkStream.ReadByte();
                throw new Exception($"Modbus error. Code: {errorCode}");
@@ -459,14 +459,14 @@
            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;
@@ -478,16 +478,16 @@
        }

        public bool[] ReadDiscreteInputs(int startingAddress, int quantity) {
            // 报文结构与ReadCoils几乎相同，仅功能码改为0x02
            // 报文结构与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[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[7] = 0x02; // 功能码:读离散输入
            request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
            request[9] = (byte)startingAddress; // 起始地址低字节
            request[10] = (byte)(quantity >> 8); // 数量高字节
@@ -499,7 +499,7 @@
            byte[] responseHeader = new byte[8];
            _networkStream.Read(responseHeader, 0, 8);

            // 校验和异常处理（参考ReadCoils）
            // 校验和异常处理 (参考ReadCoils) 
            if (responseHeader[7] == 0x82) // 异常响应
            {
                int errorCode = _networkStream.ReadByte();
@@ -525,16 +525,16 @@
            if (quantity < 1 || quantity > 125)
                throw new ArgumentException("Quantity must be between 1 and 125");

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

            // 读取响应头（8字节）
            // 读取响应头 (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、单元标识符
            // 校验事务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）
            // 检查异常响应 (功能码 + 0x80) 
            if (responseHeader[7] == 0x83) {
                int errorCode = _networkStream.ReadByte();
                throw new Exception($"Modbus error. Code: {errorCode}");
@@ -563,14 +563,14 @@
            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;
@@ -587,22 +587,22 @@
            // 构建Modbus TCP请求报文
            byte[] request = new byte[12];

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

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

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

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

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

            // 起始地址
@@ -677,7 +677,7 @@

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

            // 响应应与请求完全一致（回显）
            // 响应应与请求完全一致 (回显) 
            byte[] response = new byte[12];
            int bytesRead = _networkStream.Read(response, 0, 12);
            if (bytesRead != 12)
@@ -708,7 +708,7 @@

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

            // 检查回显响应（同WriteSingleCoil）
            // 检查回显响应 (同WriteSingleCoil) 
            byte[] response = new byte[12];
            _networkStream.Read(response, 0, 12);
            if (!response.SequenceEqual(request))
@@ -722,7 +722,7 @@
            if (quantity < 1 || quantity > 1968)
                throw new ArgumentException("Quantity must be between 1 and 1968");

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

@@ -735,7 +735,7 @@
                }
            }

            // 构建请求报文（13 + 线圈字节数）
            // 构建请求报文 (13 + 线圈字节数) 
            byte[] request = new byte[13 + coilBytes.Length];
            request[0] = 0x00; // 事务ID高字节
            request[1] = 0x01; // 事务ID低字节
@@ -744,7 +744,7 @@
            request[4] = (byte)((7 + coilBytes.Length) >> 8); // 长度高字节
            request[5] = (byte)(7 + coilBytes.Length); // 长度低字节
            request[6] = unitIdentifier;
            request[7] = 0x0F; // 功能码（写多个线圈）
            request[7] = 0x0F; // 功能码 (写多个线圈) 
            request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
            request[9] = (byte)startingAddress; // 起始地址低字节
            request[10] = (byte)(quantity >> 8); // 数量高字节
@@ -755,7 +755,7 @@
            // 发送请求
            _networkStream.Write(request, 0, request.Length);

            // 读取响应（固定12字节）
            // 读取响应 (固定12字节) 
            byte[] response = new byte[12];
            int bytesRead = _networkStream.Read(response, 0, 12);
            if (bytesRead != 12)
@@ -774,14 +774,14 @@
            if (quantity < 1 || quantity > 123)
                throw new ArgumentException("Quantity must be between 1 and 123");

            // 将ushort数组转换为字节数组（大端序）
            // 将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 + 值字节数）
            // 构建请求报文 (13 + 值字节数) 
            byte[] request = new byte[13 + valueBytes.Length];
            request[0] = 0x00; // 事务ID高字节
            request[1] = 0x01; // 事务ID低字节
@@ -790,7 +790,7 @@
            request[4] = (byte)((7 + valueBytes.Length) >> 8); // 长度高字节
            request[5] = (byte)(7 + valueBytes.Length); // 长度低字节
            request[6] = unitIdentifier;
            request[7] = 0x10; // 功能码（写多个寄存器）
            request[7] = 0x10; // 功能码 (写多个寄存器) 
            request[8] = (byte)(startingAddress >> 8); // 起始地址高字节
            request[9] = (byte)startingAddress; // 起始地址低字节
            request[10] = (byte)(quantity >> 8); // 数量高字节
@@ -801,7 +801,7 @@
            // 发送请求
            _networkStream.Write(request, 0, request.Length);

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