WinForms实战：5分钟搞定C#与汇川PLC的ModbusTCP通信（附完整源码）

# 从零到一：用C# WinForms快速构建汇川PLC ModbusTCP通信工具最近在做一个设备监控项目，需要实时采集产线上几台汇川PLC的数据。刚开始接触工业通信时，总觉得Modbus协议复杂难懂，各种功能码、寄存器地址让人眼花缭乱。但实际做下来才发现，只要掌握几个核心要点，用C# WinForms快速搭建一个可用的通信工具，真的不需要太多时间。今天我就把自己踩过的坑和总结的经验分享出来，希望能帮到那些需要在短时间内实现PLC通信功能的开发者。对于大多数工业场景来说，我们并不需要从零开始实现Modbus协议栈。市面上已经有成熟的第三方库可以大大简化开发流程。更重要的是，我们需要理解PLC通信的本质——它本质上就是客户端（我们的上位机程序）通过TCP/IP协议向服务器（PLC）发送特定的数据包，然后解析返回的数据包。理解了这一点，整个开发过程就会清晰很多。 ## 1. 环境准备与项目搭建 ### 1.1 选择合适的开发环境我推荐使用Visual Studio 2022或更高版本，社区版完全免费且功能足够强大。对于.NET版本的选择，考虑到工业现场的稳定性要求，我建议使用**.NET Framework 4.7.2**或更高版本。这个版本在Windows系统上兼容性最好，而且很多工业现场的工控机可能还在使用较老的Windows系统。 > 注意：虽然.NET Core/ .NET 5+是微软的新方向，但在工业控制领域，.NET Framework的成熟度和稳定性仍然是首选。如果你的项目需要跨平台，再考虑使用.NET Core。创建一个新的WinForms项目时，我习惯按照以下结构组织： ``` InovancePLCCommunicator/ ├── Properties/ ├── References/ ├── Forms/ │ └── MainForm.cs ├── Models/ │ ├── PLCDevice.cs │ └── CommunicationConfig.cs ├── Services/ │ ├── ModbusService.cs │ └── DataLogger.cs ├── Utilities/ │ └── ByteConverter.cs └── Program.cs ``` ### 1.2 添加必要的NuGet包 Modbus通信最常用的库是**NModbus**，它支持RTU、ASCII和TCP三种协议。在NuGet包管理器中搜索并安装： ```bash Install-Package NModbus Install-Package NModbus.Serial ``` 如果你需要更高级的功能，比如异步操作支持更好的库，可以考虑**EasyModbusTCP**： ```bash Install-Package EasyModbusTCP ``` 这里我以NModbus为例，因为它更接近协议底层，有助于理解Modbus的工作原理。安装完成后，你的项目引用中应该能看到： - NModbus - NModbus.Serial（虽然我们主要用TCP，但这个包包含了一些基础工具类） ### 1.3 基础界面设计 WinForms的界面设计要简洁实用。对于PLC通信工具，我通常包含以下几个核心区域： 1. **连接配置区**：IP地址、端口号（默认502）、站号（Slave ID） 2. **数据读写区**：地址输入、数据类型选择、读写按钮 3. **状态显示区**：连接状态、通信日志、错误信息 4. **数据展示区**：表格或文本框显示读取到的数据一个简单的设计布局可以参考下面的表格： | 区域 | 控件类型 | 主要功能 | |------|----------|----------| | 连接配置 | TextBox + Button | 输入PLC IP，建立/断开连接 | | 寄存器操作 | ComboBox + TextBox + Button | 选择功能码，输入地址，执行读写 | | 状态监控 | Label + RichTextBox | 显示连接状态和通信日志 | | 数据展示 | DataGridView | 以表格形式展示读取的数据 | 在实际编码时，我会先设计好界面，然后逐步添加功能。记住，工业软件的首要原则是**稳定可靠**，其次才是美观。 ## 2. ModbusTCP核心通信实现 ### 2.1 理解ModbusTCP协议栈在开始编码之前，我们需要对ModbusTCP的协议格式有个基本了解。与ModbusRTU不同，ModbusTCP在应用层数据单元（ADU）前添加了MBAP头（Modbus Application Protocol Header）。一个完整的ModbusTCP请求报文结构如下： | 字段 | 长度（字节） | 说明 | |------|-------------|------| | 事务标识符 | 2 | 用于请求-响应匹配，通常递增 | | 协议标识符 | 2 | ModbusTCP固定为0x0000 | | 长度字段 | 2 | 后续字节数（单元标识符+功能码+数据） | | 单元标识符 | 1 | 从站地址（Slave ID） | | 功能码 | 1 | 操作类型（如0x03读保持寄存器） | | 数据 | N | 具体参数和数据 | 对于读取保持寄存器（功能码0x03）的请求，数据部分包含： - 起始地址高字节（2字节） - 起始地址低字节（2字节） - 寄存器数量高字节（2字节） - 寄存器数量低字节（2字节）响应报文的数据部分则是实际的寄存器值。 ### 2.2 封装通信服务类我不喜欢把所有的通信逻辑都写在Form的代码后面文件里，那样会让代码难以维护。更好的做法是封装一个专门的通信服务类： ```csharp using System; using System.Net.Sockets; using Modbus.Device; namespace InovancePLCCommunicator.Services { public class ModbusTcpService : IDisposable { private TcpClient _tcpClient; private IModbusMaster _modbusMaster; private bool _isConnected = false; public bool IsConnected => _isConnected; public string LastError { get; private set; } public event EventHandler<string> LogMessage; public ModbusTcpService() { _tcpClient = new TcpClient(); _tcpClient.SendTimeout = 3000; _tcpClient.ReceiveTimeout = 3000; } public bool Connect(string ipAddress, int port = 502, byte slaveId = 1) { try { LogMessage?.Invoke(this, $"正在连接 {ipAddress}:{port}..."); // 设置连接超时 var connectTask = _tcpClient.ConnectAsync(ipAddress, port); if (!connectTask.Wait(TimeSpan.FromSeconds(5))) { LastError = "连接超时"; return false; } if (!_tcpClient.Connected) { LastError = "连接失败"; return false; } // 创建Modbus主站实例 _modbusMaster = ModbusIpMaster.CreateIp(_tcpClient); _modbusMaster.Transport.Retries = 3; _modbusMaster.Transport.ReadTimeout = 2000; _modbusMaster.Transport.WriteTimeout = 2000; _isConnected = true; LogMessage?.Invoke(this, $"连接成功，Slave ID: {slaveId}"); return true; } catch (Exception ex) { LastError = $"连接异常: {ex.Message}"; LogMessage?.Invoke(this, $"连接失败: {ex.Message}"); return false; } } public ushort[] ReadHoldingRegisters(byte slaveId, ushort startAddress, ushort numberOfRegisters) { if (!_isConnected || _modbusMaster == null) throw new InvalidOperationException("未连接到PLC"); try { LogMessage?.Invoke(this, $"读取保持寄存器: 地址={startAddress}, 数量={numberOfRegisters}"); return _modbusMaster.ReadHoldingRegisters(slaveId, startAddress, numberOfRegisters); } catch (Exception ex) { LastError = $"读取失败: {ex.Message}"; throw; } } public bool[] ReadCoils(byte slaveId, ushort startAddress, ushort numberOfCoils) { // 类似的实现... } public void Dispose() { _modbusMaster?.Dispose(); _tcpClient?.Close(); _isConnected = false; } } } ``` 这个服务类封装了最基础的连接和读取功能。在实际项目中，你可能还需要添加写入寄存器、读取输入寄存器等功能。 ### 2.3 处理字节序问题工业设备通信中最容易出问题的地方就是**字节序**。不同的PLC厂商、不同的数据类型可能有不同的字节序排列方式。汇川PLC的M区寄存器（MW地址）通常使用**大端序（Big-Endian）**，而x86架构的PC使用**小端序（Little-Endian）**。这意味着我们需要在读取和写入时进行字节序转换。我封装了一个字节序转换工具类： ```csharp using System; namespace InovancePLCCommunicator.Utilities { public static class ByteConverter { // 将两个寄存器（4字节）转换为32位整数 public static int RegistersToInt32(ushort highRegister, ushort lowRegister, bool isBigEndian = true) { byte[] bytes = new byte[4]; if (isBigEndian) { // 大端序：高位在前 bytes[0] = (byte)(highRegister >> 8); bytes[1] = (byte)(highRegister & 0xFF); bytes[2] = (byte)(lowRegister >> 8); bytes[3] = (byte)(lowRegister & 0xFF); } else { // 小端序：低位在前 bytes[0] = (byte)(lowRegister & 0xFF); bytes[1] = (byte)(lowRegister >> 8); bytes[2] = (byte)(highRegister & 0xFF); bytes[3] = (byte)(highRegister >> 8); } return BitConverter.ToInt32(bytes, 0); } // 将32位整数转换为两个寄存器 public static void Int32ToRegisters(int value, out ushort register1, out ushort register2, bool isBigEndian = true) { byte[] bytes = BitConverter.GetBytes(value); if (isBigEndian) { register1 = (ushort)((bytes[0] << 8) | bytes[1]); register2 = (ushort)((bytes[2] << 8) | bytes[3]); } else { register1 = (ushort)((bytes[2] << 8) | bytes[3]); register2 = (ushort)((bytes[0] << 8) | bytes[1]); } } // 单精度浮点数转换 public static float RegistersToFloat(ushort register1, ushort register2, bool isBigEndian = true) { byte[] bytes = new byte[4]; if (isBigEndian) { bytes[0] = (byte)(register1 >> 8); bytes[1] = (byte)(register1 & 0xFF); bytes[2] = (byte)(register2 >> 8); bytes[3] = (byte)(register2 & 0xFF); } else { bytes[0] = (byte)(register2 & 0xFF); bytes[1] = (byte)(register2 >> 8); bytes[2] = (byte)(register1 & 0xFF); bytes[3] = (byte)(register1 >> 8); } return BitConverter.ToSingle(bytes, 0); } } } ``` 在实际使用中，我发现汇川PLC对于不同的数据类型可能有不同的字节序要求。最稳妥的方法是先进行测试：写入一个已知的值，然后读取回来，观察字节的排列顺序。 ## 3. 汇川PLC M区寄存器操作实战 ### 3.1 理解M区寄存器的地址映射汇川PLC的M区寄存器在Modbus协议中映射为**保持寄存器**（Holding Registers），使用功能码0x03进行读取，0x06或0x10进行写入。这里有一个关键点需要理解：PLC中的MW地址与Modbus地址的对应关系。在汇川PLC中： - **MW0** 对应 Modbus地址 **0** - **MW1** 对应 Modbus地址 **1** - **MW100** 对应 Modbus地址 **100** 但要注意，有些PLC厂商的地址映射可能需要偏移。比如西门子PLC的MW0可能对应Modbus地址400001。汇川相对简单，通常是直接映射。对于不同数据类型的存储，需要了解： | 数据类型 | 占用寄存器数 | 说明 | |----------|-------------|------| | BOOL | 1位（不单独占用） | 通常用线圈操作，或寄存器的某一位 | | BYTE | 0.5个寄存器 | 实际存储时占用一个寄存器的高8位或低8位 | | WORD | 1个寄存器 | 16位无符号整数 | | INT | 1个寄存器 | 16位有符号整数 | | DWORD | 2个寄存器 | 32位无符号整数 | | DINT | 2个寄存器 | 32位有符号整数 | | REAL | 2个寄存器 | 单精度浮点数 | ### 3.2 实现多功能读写操作基于前面的通信服务类，我们可以实现一个更完整的读写管理器： ```csharp using System; using System.Collections.Generic; using System.Threading.Tasks; namespace InovancePLCCommunicator.Services { public class PLCDataManager { private readonly ModbusTcpService _modbusService; private readonly Dictionary<string, DataItem> _dataItems; public PLCDataManager(ModbusTcpService modbusService) { _modbusService = modbusService; _dataItems = new Dictionary<string, DataItem>(); } // 定义支持的数据类型 public enum DataType { Bool, Byte, Int16, UInt16, Int32, UInt32, Float, Double, String } // 数据项定义 public class DataItem { public string Name { get; set; } public DataType Type { get; set; } public ushort StartAddress { get; set; } public ushort Length { get; set; } public object Value { get; set; } public DateTime LastUpdate { get; set; } public bool IsValid { get; set; } } // 批量读取数据项 public async Task<bool> ReadDataItemsAsync(byte slaveId, List<DataItem> items) { try { // 按地址排序，优化读取效率 items.Sort((a, b) => a.StartAddress.CompareTo(b.StartAddress)); foreach (var item in items) { switch (item.Type) { case DataType.Bool: var coils = _modbusService.ReadCoils(slaveId, item.StartAddress, item.Length); item.Value = coils.Length > 0 ? coils[0] : false; break; case DataType.Int16: var registers = _modbusService.ReadHoldingRegisters(slaveId, item.StartAddress, 1); item.Value = (short)registers[0]; break; case DataType.UInt16: registers = _modbusService.ReadHoldingRegisters(slaveId, item.StartAddress, 1); item.Value = registers[0]; break; case DataType.Int32: case DataType.UInt32: case DataType.Float: registers = _modbusService.ReadHoldingRegisters(slaveId, item.StartAddress, 2); if (item.Type == DataType.Int32) item.Value = ByteConverter.RegistersToInt32(registers[0], registers[1]); else if (item.Type == DataType.UInt32) item.Value = (uint)ByteConverter.RegistersToInt32(registers[0], registers[1]); else item.Value = ByteConverter.RegistersToFloat(registers[0], registers[1]); break; case DataType.String: // 字符串需要特殊处理，通常每个字符占用两个字节 ushort stringLength = (ushort)(item.Length * 2); registers = _modbusService.ReadHoldingRegisters(slaveId, item.StartAddress, stringLength); item.Value = RegistersToString(registers); break; } item.LastUpdate = DateTime.Now; item.IsValid = true; } return true; } catch (Exception ex) { // 记录错误，但继续处理其他项 Console.WriteLine($"读取数据项失败: {ex.Message}"); return false; } } private string RegistersToString(ushort[] registers) { // 将寄存器数组转换为字符串 // 这里假设每个寄存器存储一个字符（ASCII或Unicode） char[] chars = new char[registers.Length]; for (int i = 0; i < registers.Length; i++) { chars[i] = (char)registers[i]; } return new string(chars).TrimEnd('\0'); } // 定时轮询方法 public async Task StartPollingAsync(byte slaveId, int intervalMs = 1000) { while (_modbusService.IsConnected) { try { var itemsToRead = new List<DataItem>(_dataItems.Values); await ReadDataItemsAsync(slaveId, itemsToRead); // 更新数据项字典 foreach (var item in itemsToRead) { if (_dataItems.ContainsKey(item.Name)) _dataItems[item.Name] = item; } // 触发数据更新事件 OnDataUpdated?.Invoke(this, _dataItems); await Task.Delay(intervalMs); } catch (Exception ex) { Console.WriteLine($"轮询异常: {ex.Message}"); await Task.Delay(5000); // 异常后等待更长时间 } } } public event EventHandler<Dictionary<string, DataItem>> OnDataUpdated; } } ``` 这个管理器类提供了数据项的批量读取和定时轮询功能，在实际项目中非常实用。 ### 3.3 错误处理与重试机制工业现场的网络环境可能不稳定，因此健壮的错误处理机制至关重要。我通常实现一个带重试的通信包装器： ```csharp public class RobustModbusClient { private readonly ModbusTcpService _innerClient; private readonly int _maxRetries; private readonly int _retryDelayMs; public RobustModbusClient(ModbusTcpService innerClient, int maxRetries = 3, int retryDelayMs = 100) { _innerClient = innerClient; _maxRetries = maxRetries; _retryDelayMs = retryDelayMs; } public async Task<T> ExecuteWithRetryAsync<T>(Func<Task<T>> operation, string operationName) { int retryCount = 0; while (retryCount <= _maxRetries) { try { return await operation(); } catch (SocketException ex) when (retryCount < _maxRetries) { retryCount++; Console.WriteLine($"{operationName} 失败 (尝试 {retryCount}/{_maxRetries}): {ex.Message}"); if (retryCount < _maxRetries) { await Task.Delay(_retryDelayMs * retryCount); // 指数退避 // 尝试重新连接 if (!_innerClient.IsConnected) { Console.WriteLine("尝试重新连接..."); // 这里需要根据实际情况实现重连逻辑 } } } catch (Exception ex) { // 非网络错误，直接抛出 Console.WriteLine($"{operationName} 发生非重试错误: {ex.Message}"); throw; } } throw new InvalidOperationException($"{operationName} 在 {_maxRetries} 次重试后仍失败"); } public async Task<ushort[]> ReadRegistersWithRetry(byte slaveId, ushort address, ushort count) { return await ExecuteWithRetryAsync( () => Task.FromResult(_innerClient.ReadHoldingRegisters(slaveId, address, count)), $"读取寄存器 [{address}, {count}]" ); } } ``` 这种重试机制可以显著提高通信的稳定性，特别是在网络波动较大的环境中。 ## 4. 高级功能与性能优化 ### 4.1 异步编程模式在WinForms中使用异步编程需要特别注意线程安全问题。所有UI更新必须在UI线程上执行： ```csharp public partial class MainForm : Form { private readonly ModbusTcpService _modbusService; private readonly PLCDataManager _dataManager; private CancellationTokenSource _pollingCts; public MainForm() { InitializeComponent(); _modbusService = new ModbusTcpService(); _dataManager = new PLCDataManager(_modbusService); // 订阅日志事件 _modbusService.LogMessage += OnLogMessage; _dataManager.OnDataUpdated += OnDataUpdated; } private void OnLogMessage(object sender, string message) { // 确保在UI线程上更新 if (rtbLog.InvokeRequired) { rtbLog.Invoke(new Action(() => OnLogMessage(sender, message))); return; } rtbLog.AppendText($"{DateTime.Now:HH:mm:ss} - {message}\n"); rtbLog.ScrollToCaret(); } private void OnDataUpdated(object sender, Dictionary<string, PLCDataManager.DataItem> data) { if (dataGridView.InvokeRequired) { dataGridView.Invoke(new Action(() => OnDataUpdated(sender, data))); return; } // 更新DataGridView UpdateDataGrid(data); } private async void btnStartPolling_Click(object sender, EventArgs e) { if (_pollingCts != null) { // 停止轮询 _pollingCts.Cancel(); btnStartPolling.Text = "开始轮询"; _pollingCts = null; return; } try { _pollingCts = new CancellationTokenSource(); btnStartPolling.Text = "停止轮询"; // 在后台线程执行轮询 await Task.Run(async () => { await _dataManager.StartPollingAsync( slaveId: (byte)nudSlaveId.Value, intervalMs: (int)nudInterval.Value ); }, _pollingCts.Token); } catch (OperationCanceledException) { // 轮询被取消，正常退出 OnLogMessage(this, "轮询已停止"); } catch (Exception ex) { MessageBox.Show($"轮询异常: {ex.Message}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error); } finally { if (_pollingCts != null) { _pollingCts.Dispose(); _pollingCts = null; } btnStartPolling.Text = "开始轮询"; } } private void UpdateDataGrid(Dictionary<string, PLCDataManager.DataItem> data) { // 清空现有行 dataGridView.Rows.Clear(); foreach (var item in data.Values) { dataGridView.Rows.Add( item.Name, item.Type.ToString(), $"MW{item.StartAddress}", item.Value?.ToString() ?? "N/A", item.LastUpdate.ToString("HH:mm:ss"), item.IsValid ? "✓" : "✗" ); } } } ``` ### 4.2 数据缓存与历史记录对于监控系统，通常需要保存历史数据。我实现了一个简单的数据记录器： ```csharp public class DataLogger { private readonly string _logDirectory; private readonly int _maxFileSizeMB; private readonly Queue<DataRecord> _memoryCache; private readonly int _cacheCapacity; public DataLogger(string logDirectory = "Logs", int maxFileSizeMB = 10, int cacheCapacity = 1000) { _logDirectory = logDirectory; _maxFileSizeMB = maxFileSizeMB; _cacheCapacity = cacheCapacity; _memoryCache = new Queue<DataRecord>(cacheCapacity); // 确保日志目录存在 Directory.CreateDirectory(_logDirectory); } public class DataRecord { public DateTime Timestamp { get; set; } public string TagName { get; set; } public object Value { get; set; } public string Quality { get; set; } // Good, Bad, Uncertain } public void LogData(string tagName, object value, string quality = "Good") { var record = new DataRecord { Timestamp = DateTime.Now, TagName = tagName, Value = value, Quality = quality }; // 添加到内存缓存 lock (_memoryCache) { if (_memoryCache.Count >= _cacheCapacity) _memoryCache.Dequeue(); _memoryCache.Enqueue(record); } // 异步写入文件 Task.Run(() => WriteToFile(record)); } private void WriteToFile(DataRecord record) { try { string dateStr = DateTime.Now.ToString("yyyyMMdd"); string filePath = Path.Combine(_logDirectory, $"DataLog_{dateStr}.csv"); // 检查文件大小 if (File.Exists(filePath)) { var fileInfo = new FileInfo(filePath); if (fileInfo.Length > _maxFileSizeMB * 1024 * 1024) { // 文件过大，创建新文件 string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss"); string newPath = Path.Combine(_logDirectory, $"DataLog_{dateStr}_{timestamp}.csv"); File.Move(filePath, newPath); } } // 写入CSV bool isNewFile = !File.Exists(filePath); using (var writer = new StreamWriter(filePath, true, Encoding.UTF8)) { if (isNewFile) { // 写入CSV头 writer.WriteLine("Timestamp,TagName,Value,Quality"); } writer.WriteLine($"{record.Timestamp:yyyy-MM-dd HH:mm:ss.fff},{record.TagName},{record.Value},{record.Quality}"); } } catch (Exception ex) { Console.WriteLine($"写入日志失败: {ex.Message}"); } } public List<DataRecord> GetRecentData(string tagName = null, int maxRecords = 100) { lock (_memoryCache) { var query = _memoryCache.AsEnumerable(); if (!string.IsNullOrEmpty(tagName)) query = query.Where(r => r.TagName == tagName); return query .OrderByDescending(r => r.Timestamp) .Take(maxRecords) .ToList(); } } } ``` ### 4.3 性能监控与诊断为了确保通信的稳定性，我通常会添加性能监控功能： ```csharp public class CommunicationMonitor { private readonly List<CommunicationMetric> _metrics; private readonly object _lock = new object(); private DateTime _lastResetTime; public CommunicationMonitor() { _metrics = new List<CommunicationMetric>(); _lastResetTime = DateTime.Now; } public class CommunicationMetric { public DateTime Timestamp { get; set; } public string Operation { get; set; } public bool Success { get; set; } public long DurationMs { get; set; } public int DataSize { get; set; } public string ErrorMessage { get; set; } } public void RecordOperation(string operation, bool success, long durationMs, int dataSize = 0, string errorMessage = null) { lock (_lock) { var metric = new CommunicationMetric { Timestamp = DateTime.Now, Operation = operation, Success = success, DurationMs = durationMs, DataSize = dataSize, ErrorMessage = errorMessage }; _metrics.Add(metric); // 保持最近1000条记录 if (_metrics.Count > 1000) _metrics.RemoveAt(0); } } public PerformanceSummary GetSummary(TimeSpan period) { lock (_lock) { var cutoffTime = DateTime.Now - period; var recentMetrics = _metrics.Where(m => m.Timestamp >= cutoffTime).ToList(); if (recentMetrics.Count == 0) return new PerformanceSummary(); var successfulOps = recentMetrics.Where(m => m.Success).ToList(); var failedOps = recentMetrics.Where(m => !m.Success).ToList(); return new PerformanceSummary { TotalOperations = recentMetrics.Count, SuccessfulOperations = successfulOps.Count, FailedOperations = failedOps.Count, SuccessRate = (double)successfulOps.Count / recentMetrics.Count * 100, AverageDurationMs = successfulOps.Any() ? successfulOps.Average(m => m.DurationMs) : 0, MaxDurationMs = successfulOps.Any() ? successfulOps.Max(m => m.DurationMs) : 0, MinDurationMs = successfulOps.Any() ? successfulOps.Min(m => m.DurationMs) : 0, TotalDataSize = recentMetrics.Sum(m => m.DataSize), LastError = failedOps.LastOrDefault()?.ErrorMessage }; } } public class PerformanceSummary { public int TotalOperations { get; set; } public int SuccessfulOperations { get; set; } public int FailedOperations { get; set; } public double SuccessRate { get; set; } public double AverageDurationMs { get; set; } public double MaxDurationMs { get; set; } public double MinDurationMs { get; set; } public long TotalDataSize { get; set; } public string LastError { get; set; } public override string ToString() { return $"成功率: {SuccessRate:F1}% | " + $"平均耗时: {AverageDurationMs:F1}ms | " + $"总操作: {TotalOperations}"; } } public void Reset() { lock (_lock) { _metrics.Clear(); _lastResetTime = DateTime.Now; } } } ``` 这个监控器可以帮助我们发现性能瓶颈和通信问题。在实际项目中，我通常会定期（比如每分钟）将性能摘要显示在状态栏上。 ### 4.4 配置管理与持久化工业软件通常需要保存配置信息。我使用JSON格式保存配置： ```csharp public class AppConfig { public string LastIpAddress { get; set; } = "192.168.1.100"; public int LastPort { get; set; } = 502; public byte LastSlaveId { get; set; } = 1; public int PollingInterval { get; set; } = 1000; public List<DataTagConfig> DataTags { get; set; } = new List<DataTagConfig>(); public bool AutoConnect { get; set; } = false; public bool AutoStartPolling { get; set; } = false; public string LogLevel { get; set; } = "Info"; public class DataTagConfig { public string Name { get; set; } public string DataType { get; set; } public ushort Address { get; set; } public ushort Length { get; set; } public string Description { get; set; } public double ScalingFactor { get; set; } = 1.0; public double Offset { get; set; } = 0.0; public string Unit { get; set; } public double AlarmHigh { get; set; } public double AlarmLow { get; set; } } } public class ConfigManager { private readonly string _configPath; private AppConfig _config; public ConfigManager(string configFileName = "config.json") { string appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData); string appFolder = Path.Combine(appDataPath, "InovancePLCCommunicator"); Directory.CreateDirectory(appFolder); _configPath = Path.Combine(appFolder, configFileName); } public AppConfig LoadConfig() { try { if (File.Exists(_configPath)) { string json = File.ReadAllText(_configPath, Encoding.UTF8); _config = JsonConvert.DeserializeObject<AppConfig>(json); } else { _config = new AppConfig(); SaveConfig(); // 创建默认配置 } return _config; } catch (Exception ex) { Console.WriteLine($"加载配置失败: {ex.Message}"); return new AppConfig(); // 返回默认配置 } } public void SaveConfig() { try { string json = JsonConvert.SerializeObject(_config, Formatting.Indented); File.WriteAllText(_configPath, json, Encoding.UTF8); } catch (Exception ex) { Console.WriteLine($"保存配置失败: {ex.Message}"); } } public void UpdateConfig(Action<AppConfig> updateAction) { updateAction?.Invoke(_config); SaveConfig(); } } ``` 使用Newtonsoft.Json库来处理JSON序列化： ```bash Install-Package Newtonsoft.Json ``` 这样，用户的所有配置都会自动保存，下次启动时自动加载。在实际项目中，我发现很多开发者忽略了配置管理的重要性。一个好的配置系统可以让软件更加用户友好，也便于现场调试。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

下一篇 Python语音合成实战：3种免费库对比（gTTS/pyttsx3/speech）及避坑指南