using EasyModbus;
|
using GSModbus.Config;
|
using GSModbus.Database;
|
using System;
|
using System.Threading;
|
using System.Threading.Tasks;
|
|
namespace GSModbus
|
{
|
/// <summary>
|
/// 通用Modbus TCP通信管理器 - 支持配置驱动的动态通信
|
/// </summary>
|
public class UniversalModbusManager : IDisposable
|
{
|
#region 私有字段
|
|
/// <summary>
|
/// Modbus配置
|
/// </summary>
|
private ModbusConfiguration? _configuration;
|
|
/// <summary>
|
/// EasyModbus TCP客户端实例
|
/// </summary>
|
private ModbusClient? _modbusClient;
|
|
/// <summary>
|
/// 心跳定时器
|
/// </summary>
|
private System.Timers.Timer? _heartbeatTimer;
|
|
/// <summary>
|
/// 数据轮询定时器
|
/// </summary>
|
private System.Timers.Timer? _dataPollingTimer;
|
|
/// <summary>
|
/// 心跳包状态
|
/// </summary>
|
private byte _heartbeatState = 0;
|
|
/// <summary>
|
/// 连接状态标志
|
/// </summary>
|
private bool _isConnected = false;
|
|
/// <summary>
|
/// 取消令牌源
|
/// </summary>
|
private CancellationTokenSource? _cancellationTokenSource;
|
|
/// <summary>
|
/// 重试计数器
|
/// </summary>
|
private int _retryCount = 0;
|
|
/// <summary>
|
/// 数据库管理器
|
/// </summary>
|
private DatabaseManager? _databaseManager;
|
|
#endregion
|
|
#region 事件定义
|
|
/// <summary>
|
/// 连接状态改变事件
|
/// </summary>
|
public event EventHandler<bool>? ConnectionStatusChanged;
|
|
/// <summary>
|
/// 接收到动态数据事件
|
/// </summary>
|
public event EventHandler<DynamicModbusData>? DataReceived;
|
|
/// <summary>
|
/// 错误发生事件
|
/// </summary>
|
public event EventHandler<string>? ErrorOccurred;
|
|
/// <summary>
|
/// 通信统计更新事件
|
/// </summary>
|
public event EventHandler<CommunicationStats>? StatsUpdated;
|
|
/// <summary>
|
/// 数据库日志事件
|
/// </summary>
|
public event EventHandler<string>? DatabaseLogOccurred;
|
|
/// <summary>
|
/// 数据库错误事件
|
/// </summary>
|
public event EventHandler<string>? DatabaseErrorOccurred;
|
|
#endregion
|
|
#region 公共属性
|
|
/// <summary>
|
/// 获取当前连接状态
|
/// </summary>
|
public bool IsConnected => _isConnected;
|
|
/// <summary>
|
/// 获取当前配置
|
/// </summary>
|
public ModbusConfiguration? Configuration => _configuration;
|
|
/// <summary>
|
/// 通信统计信息
|
/// </summary>
|
public CommunicationStats Stats { get; private set; } = new();
|
|
#endregion
|
|
#region 构造函数
|
|
/// <summary>
|
/// 初始化通用Modbus管理器
|
/// </summary>
|
/// <param name="configuration">Modbus配置</param>
|
public UniversalModbusManager(ModbusConfiguration? configuration = null)
|
{
|
_cancellationTokenSource = new CancellationTokenSource();
|
|
if (configuration != null)
|
{
|
SetConfiguration(configuration);
|
}
|
}
|
|
#endregion
|
|
#region 配置管理方法
|
|
/// <summary>
|
/// 设置新的配置
|
/// </summary>
|
/// <param name="configuration">新配置</param>
|
public void SetConfiguration(ModbusConfiguration configuration)
|
{
|
// 如果当前已连接，需要先断开
|
if (_isConnected)
|
{
|
LogWarning("配置更改时自动断开连接");
|
Disconnect();
|
}
|
|
// 释放现有数据库管理器
|
_databaseManager?.Dispose();
|
_databaseManager = null;
|
|
_configuration = configuration;
|
|
// 释放现有资源
|
DisposeTimers();
|
|
// 初始化新配置
|
InitializeWithConfiguration();
|
|
LogInfo($"配置已更新: {configuration.ProjectName}");
|
}
|
|
/// <summary>
|
/// 根据配置初始化组件
|
/// </summary>
|
private void InitializeWithConfiguration()
|
{
|
if (_configuration == null)
|
{
|
LogError("无法初始化：配置为空");
|
return;
|
}
|
|
try
|
{
|
// 创建Modbus客户端
|
_modbusClient = new ModbusClient(_configuration.Connection.IpAddress, _configuration.Connection.Port);
|
_modbusClient.ConnectionTimeout = _configuration.Connection.ConnectionTimeoutMs;
|
|
// 初始化定时器
|
InitializeTimers();
|
|
// 初始化数据库管理器
|
InitializeDatabaseManager();
|
|
LogInfo($"已初始化Modbus客户端: {_configuration.Connection.IpAddress}:{_configuration.Connection.Port}");
|
}
|
catch (Exception ex)
|
{
|
LogError($"初始化配置时发生错误: {ex.Message}");
|
throw;
|
}
|
}
|
|
/// <summary>
|
/// 初始化定时器
|
/// </summary>
|
private void InitializeTimers()
|
{
|
if (_configuration == null) return;
|
|
// 心跳定时器
|
_heartbeatTimer = new System.Timers.Timer(_configuration.Communication.HeartbeatIntervalMs);
|
_heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
|
_heartbeatTimer.AutoReset = true;
|
|
// 数据轮询定时器
|
_dataPollingTimer = new System.Timers.Timer(_configuration.Communication.DataPollingIntervalMs);
|
_dataPollingTimer.Elapsed += OnDataPollingTimerElapsed;
|
_dataPollingTimer.AutoReset = true;
|
|
LogInfo($"定时器已初始化 - 心跳:{_configuration.Communication.HeartbeatIntervalMs}ms, 轮询:{_configuration.Communication.DataPollingIntervalMs}ms");
|
}
|
|
/// <summary>
|
/// 初始化数据库管理器
|
/// </summary>
|
private void InitializeDatabaseManager()
|
{
|
if (_configuration?.Database?.Enabled == true)
|
{
|
try
|
{
|
_databaseManager = new DatabaseManager(
|
_configuration.Database,
|
_configuration.ProjectName,
|
_configuration.Connection.IpAddress
|
);
|
|
// 订阅数据库事件
|
_databaseManager.DatabaseLogOccurred += (sender, message) => DatabaseLogOccurred?.Invoke(this, message);
|
_databaseManager.DatabaseErrorOccurred += (sender, error) => DatabaseErrorOccurred?.Invoke(this, error);
|
|
LogInfo("数据库管理器初始化成功");
|
}
|
catch (Exception ex)
|
{
|
LogError($"初始化数据库管理器失败: {ex.Message}");
|
}
|
}
|
else
|
{
|
LogInfo("数据库功能未启用");
|
}
|
}
|
|
#endregion
|
|
#region 连接管理方法
|
|
/// <summary>
|
/// 连接到PLC服务器
|
/// </summary>
|
/// <returns>连接是否成功</returns>
|
public async Task<bool> ConnectAsync()
|
{
|
if (_configuration == null)
|
{
|
LogError("无法连接：配置未设置");
|
return false;
|
}
|
|
if (_modbusClient == null)
|
{
|
LogError("无法连接：Modbus客户端未初始化");
|
return false;
|
}
|
|
try
|
{
|
LogInfo($"正在连接到PLC服务器 {_configuration.Connection.IpAddress}:{_configuration.Connection.Port}...");
|
|
// 尝试连接到PLC
|
await Task.Run(() => _modbusClient.Connect());
|
|
_isConnected = true;
|
_retryCount = 0;
|
Stats.ConnectionAttempts++;
|
Stats.LastConnectedTime = DateTime.Now;
|
|
LogInfo("成功连接到PLC服务器");
|
|
// 记录数据库日志
|
await _databaseManager?.LogCommunicationAsync(EventTypes.Connected, "成功连接到PLC服务器", true)!;
|
|
// 启动定时器
|
_heartbeatTimer?.Start();
|
_dataPollingTimer?.Start();
|
|
// 触发连接状态改变事件
|
ConnectionStatusChanged?.Invoke(this, true);
|
|
return true;
|
}
|
catch (Exception ex)
|
{
|
_isConnected = false;
|
Stats.ConnectionFailures++;
|
LogError($"连接PLC失败: {ex.Message}");
|
|
// 记录数据库错误日志
|
await _databaseManager?.LogErrorAsync("ConnectionError", $"连接PLC失败: {ex.Message}", ex, ErrorSeverity.High, _retryCount)!;
|
await _databaseManager?.LogCommunicationAsync(EventTypes.ConnectionError, ex.Message, false)!;
|
|
ConnectionStatusChanged?.Invoke(this, false);
|
|
// 如果启用自动重连，安排重连
|
if (_configuration.Communication.EnableAutoReconnect &&
|
_retryCount < _configuration.Communication.MaxRetryCount)
|
{
|
ScheduleReconnect();
|
}
|
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 断开与PLC的连接
|
/// </summary>
|
public async void Disconnect()
|
{
|
try
|
{
|
// 停止定时器
|
_heartbeatTimer?.Stop();
|
_dataPollingTimer?.Stop();
|
|
// 断开Modbus连接
|
if (_modbusClient?.Connected == true)
|
{
|
_modbusClient.Disconnect();
|
}
|
|
_isConnected = false;
|
Stats.LastDisconnectedTime = DateTime.Now;
|
LogInfo("已断开与PLC的连接");
|
|
// 记录数据库日志
|
await _databaseManager?.LogCommunicationAsync(EventTypes.Disconnected, "手动断开PLC连接", true)!;
|
|
// 触发连接状态改变事件
|
ConnectionStatusChanged?.Invoke(this, false);
|
}
|
catch (Exception ex)
|
{
|
LogError($"断开连接时发生错误: {ex.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 安排自动重连
|
/// </summary>
|
private void ScheduleReconnect()
|
{
|
if (_configuration == null || _cancellationTokenSource?.Token.IsCancellationRequested == true)
|
return;
|
|
_retryCount++;
|
var delay = _configuration.Communication.ReconnectDelayMs;
|
|
LogWarning($"将在 {delay}ms 后尝试第 {_retryCount} 次重连");
|
|
Task.Delay(delay, _cancellationTokenSource?.Token ?? CancellationToken.None).ContinueWith(async _ =>
|
{
|
if (!(_cancellationTokenSource?.Token.IsCancellationRequested ?? true))
|
{
|
await ConnectAsync();
|
}
|
}, _cancellationTokenSource?.Token ?? CancellationToken.None);
|
}
|
|
#endregion
|
|
#region 定时器事件处理
|
|
/// <summary>
|
/// 心跳定时器事件
|
/// </summary>
|
private async void OnHeartbeatTimerElapsed(object? sender, System.Timers.ElapsedEventArgs e)
|
{
|
if (!_isConnected || _configuration == null || _modbusClient == null ||
|
_cancellationTokenSource?.Token.IsCancellationRequested == true)
|
return;
|
|
try
|
{
|
// 在0和1之间交替心跳状态
|
_heartbeatState = (byte)(_heartbeatState == 0 ? 1 : 0);
|
|
// 向PLC发送心跳包
|
var heartbeatAddress = _configuration.OutputAddresses.HeartbeatAddress.Address;
|
await Task.Run(() => _modbusClient.WriteSingleRegister(heartbeatAddress, _heartbeatState));
|
|
Stats.HeartbeatsSent++;
|
LogDebug($"发送心跳包到地址 {heartbeatAddress}: {_heartbeatState}");
|
}
|
catch (Exception ex)
|
{
|
Stats.CommunicationErrors++;
|
LogError($"发送心跳包失败: {ex.Message}");
|
await HandleConnectionLoss();
|
}
|
}
|
|
/// <summary>
|
/// 数据轮询定时器事件
|
/// </summary>
|
private async void OnDataPollingTimerElapsed(object? sender, System.Timers.ElapsedEventArgs e)
|
{
|
if (!_isConnected || _configuration == null || _modbusClient == null ||
|
_cancellationTokenSource?.Token.IsCancellationRequested == true)
|
return;
|
|
try
|
{
|
// 读取PLC数据
|
var dynamicData = await ReadDynamicDataAsync();
|
if (dynamicData != null)
|
{
|
// 检查是否需要发送确认信号
|
var dataReadySignal = GetDataReadySignal(dynamicData);
|
if (dataReadySignal == 1)
|
{
|
await SendDataReadConfirmationAsync();
|
|
// 保存到数据库
|
await _databaseManager?.SaveModbusDataAsync(dynamicData)!;
|
await _databaseManager?.LogCommunicationAsync(EventTypes.DataReceived, "成功读取PLC数据", true)!;
|
|
// 触发数据接收事件
|
DataReceived?.Invoke(this, dynamicData);
|
Stats.SuccessfulReads++;
|
|
LogDebug("成功读取PLC数据并发送确认信号");
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
Stats.CommunicationErrors++;
|
LogError($"读取PLC数据失败: {ex.Message}");
|
|
// 记录数据库错误日志
|
await _databaseManager?.LogErrorAsync("DataReadError", ex.Message, ex, ErrorSeverity.Medium)!;
|
await _databaseManager?.LogCommunicationAsync(EventTypes.DataReadError, ex.Message, false)!;
|
}
|
finally
|
{
|
// 更新统计信息
|
StatsUpdated?.Invoke(this, Stats);
|
}
|
}
|
|
#endregion
|
|
#region 数据读取方法
|
|
/// <summary>
|
/// 读取动态配置的数据
|
/// </summary>
|
/// <returns>动态数据对象</returns>
|
private async Task<DynamicModbusData?> ReadDynamicDataAsync()
|
{
|
if (_configuration?.InputAddresses == null || _modbusClient == null)
|
return null;
|
|
var dynamicData = new DynamicModbusData
|
{
|
SourceConfiguration = _configuration,
|
ReadTime = DateTime.Now
|
};
|
|
try
|
{
|
// 读取控制信号
|
await ReadFieldGroup(dynamicData, _configuration.InputAddresses.ControlSignals, "控制信号");
|
|
// 读取产品数据
|
await ReadFieldGroup(dynamicData, _configuration.InputAddresses.ProductData, "产品数据");
|
|
// 读取测量数据
|
await ReadFieldGroup(dynamicData, _configuration.InputAddresses.MeasurementData, "测量数据");
|
|
return dynamicData;
|
}
|
catch (Exception ex)
|
{
|
LogError($"读取动态数据时发生错误: {ex.Message}");
|
return null;
|
}
|
}
|
|
/// <summary>
|
/// 读取字段组数据
|
/// </summary>
|
/// <param name="dynamicData">动态数据容器</param>
|
/// <param name="fieldGroup">字段组配置</param>
|
/// <param name="groupName">组名称（用于日志）</param>
|
private async Task ReadFieldGroup(DynamicModbusData dynamicData, Dictionary<string, DataField> fieldGroup, string groupName)
|
{
|
if (_modbusClient == null)
|
{
|
LogWarning($"Modbus客户端为null，无法读取 {groupName}");
|
return;
|
}
|
|
if (!_isConnected)
|
{
|
LogWarning($"Modbus未连接，无法读取 {groupName}");
|
return;
|
}
|
|
if (fieldGroup == null || fieldGroup.Count == 0)
|
{
|
LogDebug($"{groupName} 没有配置字段，跳过读取");
|
return;
|
}
|
|
foreach (var kvp in fieldGroup)
|
{
|
var fieldName = kvp.Key;
|
var fieldConfig = kvp.Value;
|
|
try
|
{
|
// 检查Modbus客户端状态
|
if (_modbusClient == null || !_modbusClient.Connected)
|
{
|
LogWarning($"Modbus客户端未连接，跳过字段 '{fieldName}'");
|
continue;
|
}
|
|
// 读取原始寄存器数据
|
var registers = await Task.Run(() =>
|
_modbusClient.ReadHoldingRegisters(fieldConfig.Address, fieldConfig.Length));
|
|
// 验证寄存器读取结果的有效性
|
ValidateRegisterData(fieldName, fieldConfig, registers);
|
|
// 检查读取结果是否为null
|
if (registers == null)
|
{
|
LogWarning($"字段 '{fieldName}' 读取结果为null，地址: {fieldConfig.Address}, 长度: {fieldConfig.Length}");
|
continue;
|
}
|
|
// 记录原始寄存器数据用于调试
|
LogDebug($"[RAW-DATA] 字段 '{fieldName}' 原始寄存器: [{string.Join(", ", registers)}] (十六进制: [{string.Join(", ", registers.Select(r => $"0x{r:X4}"))}])");
|
|
// 详细记录每个寄存器的字节分解
|
for (int i = 0; i < registers.Length; i++)
|
{
|
var reg = registers[i];
|
var highByte = (byte)((reg >> 8) & 0xFF);
|
var lowByte = (byte)(reg & 0xFF);
|
LogDebug($"[RAW-DATA] 寄存器{i}: {reg} (0x{reg:X4}) → 高字节:{highByte}('{(char)highByte}') 低字节:{lowByte}('{(char)lowByte}')");
|
}
|
|
// 验证数据长度
|
if (!ModbusDataParser.ValidateRegisterLength(registers, fieldConfig))
|
{
|
LogWarning($"字段 '{fieldName}' 的数据长度不足：期望{fieldConfig.Length}，实际{registers?.Length ?? 0}");
|
continue;
|
}
|
|
// 解析数据
|
var parsedValue = ModbusDataParser.ParseFieldData(registers, fieldConfig);
|
|
// 存储到动态数据容器
|
dynamicData.SetFieldData(fieldName, parsedValue, registers);
|
|
LogDebug($"成功读取字段 '{fieldName}': {parsedValue}");
|
}
|
catch (Exception ex)
|
{
|
LogError($"读取字段 '{fieldName}' 失败: {ex.Message}");
|
|
// 记录详细错误信息
|
await _databaseManager?.LogErrorAsync(
|
"FieldReadError",
|
$"读取字段 '{fieldName}' 失败: {ex.Message}",
|
ex,
|
ErrorSeverity.Medium)!;
|
|
// 继续读取其他字段
|
}
|
}
|
}
|
|
/// <summary>
|
/// 获取数据就绪信号
|
/// </summary>
|
private byte GetDataReadySignal(DynamicModbusData data)
|
{
|
// 查找数据就绪信号字段
|
var controlSignals = _configuration?.InputAddresses.ControlSignals;
|
if (controlSignals != null)
|
{
|
foreach (var kvp in controlSignals)
|
{
|
var fieldConfig = kvp.Value;
|
if (fieldConfig.Description?.Contains("数据") == true &&
|
fieldConfig.Description?.Contains("就绪") == true)
|
{
|
return data.GetByte(kvp.Key);
|
}
|
}
|
}
|
|
// 如果没有找到明确的数据就绪信号，返回1（假设数据总是就绪）
|
return 1;
|
}
|
|
#endregion
|
|
#region 数据验证方法
|
|
/// <summary>
|
/// 验证寄存器数据的有效性
|
/// </summary>
|
/// <param name="fieldName">字段名</param>
|
/// <param name="fieldConfig">字段配置</param>
|
/// <param name="registers">读取的寄存器数据</param>
|
private void ValidateRegisterData(string fieldName, DataField fieldConfig, int[]? registers)
|
{
|
if (registers == null)
|
{
|
LogWarning($"[VALIDATE] 字段 '{fieldName}' 寄存器数据为null");
|
return;
|
}
|
|
LogDebug($"[VALIDATE] 字段 '{fieldName}' 原始数据验证:");
|
LogDebug($"[VALIDATE] - 地址: {fieldConfig.Address}, 期望长度: {fieldConfig.Length}, 实际长度: {registers.Length}");
|
LogDebug($"[VALIDATE] - 数据类型: {fieldConfig.DataType}");
|
|
// 检查数据长度
|
if (registers.Length != fieldConfig.Length)
|
{
|
LogWarning($"[VALIDATE] 字段 '{fieldName}' 数据长度不匹配: 期望{fieldConfig.Length}, 实际{registers.Length}");
|
}
|
|
// 检查是否包含有效数据
|
var hasNonZeroData = registers.Any(r => r != 0);
|
if (!hasNonZeroData)
|
{
|
LogWarning($"[VALIDATE] 字段 '{fieldName}' 所有寄存器都为0，可能是无效数据");
|
}
|
|
// 检查数据范围（16位有符号整数范围）
|
var outOfRangeCount = registers.Count(r => r < -32768 || r > 32767);
|
if (outOfRangeCount > 0)
|
{
|
LogWarning($"[VALIDATE] 字段 '{fieldName}' 有{outOfRangeCount}个寄存器值超出16位有符号整数范围");
|
}
|
|
// 特殊数据模式检测
|
DetectSpecialDataPatterns(fieldName, registers);
|
}
|
|
/// <summary>
|
/// 检测特殊的数据模式
|
/// </summary>
|
/// <param name="fieldName">字段名</param>
|
/// <param name="registers">寄存器数据</param>
|
private void DetectSpecialDataPatterns(string fieldName, int[] registers)
|
{
|
// 检测全FF模式（通信错误）
|
if (registers.All(r => r == -1 || r == 0xFFFF))
|
{
|
LogWarning($"[PATTERN] 字段 '{fieldName}' 检测到全FF模式，可能是通信错误");
|
}
|
|
// 检测常见的错误码模式
|
if (registers.Length >= 2)
|
{
|
var combined = ((long)((uint)registers[0] & 0xFFFF) << 16) | ((uint)registers[1] & 0xFFFF);
|
if (combined == 0xE2400001)
|
{
|
LogInfo($"[PATTERN] 字段 '{fieldName}' 检测到已知的无效数据标识 0xE2400001");
|
}
|
}
|
|
// 检测ASCII字符模式（用于字符串和时间戳字段）
|
if (registers.Any(r => IsLikelyAsciiData(r)))
|
{
|
LogDebug($"[PATTERN] 字段 '{fieldName}' 包含可能的ASCII字符数据");
|
}
|
}
|
|
/// <summary>
|
/// 检查寄存器值是否可能包含ASCII字符
|
/// </summary>
|
/// <param name="register">寄存器值</param>
|
/// <returns>是否可能是ASCII数据</returns>
|
private bool IsLikelyAsciiData(int register)
|
{
|
if (register == 0) return false;
|
|
var highByte = (byte)((register >> 8) & 0xFF);
|
var lowByte = (byte)(register & 0xFF);
|
|
// 检查是否为可打印ASCII字符范围（32-126）
|
return (highByte >= 32 && highByte <= 126) || (lowByte >= 32 && lowByte <= 126);
|
}
|
|
#endregion
|
|
#region 数据发送方法
|
|
/// <summary>
|
/// 向PLC发送数据读取确认信号
|
/// </summary>
|
private async Task SendDataReadConfirmationAsync()
|
{
|
if (_configuration == null || _modbusClient == null) return;
|
|
try
|
{
|
var confirmAddress = _configuration.OutputAddresses.DataConfirmationAddress.Address;
|
await Task.Run(() => _modbusClient.WriteSingleRegister(confirmAddress, 1));
|
|
Stats.ConfirmationsSent++;
|
LogDebug($"已向地址 {confirmAddress} 发送数据读取确认信号");
|
}
|
catch (Exception ex)
|
{
|
LogError($"发送数据确认信号失败: {ex.Message}");
|
throw;
|
}
|
}
|
|
#endregion
|
|
#region 错误处理方法
|
|
/// <summary>
|
/// 处理连接丢失
|
/// </summary>
|
private Task HandleConnectionLoss()
|
{
|
if (_isConnected)
|
{
|
LogWarning("检测到连接丢失");
|
|
Disconnect();
|
|
// 如果启用自动重连
|
if (_configuration?.Communication.EnableAutoReconnect == true &&
|
_retryCount < _configuration.Communication.MaxRetryCount)
|
{
|
ScheduleReconnect();
|
}
|
}
|
|
return Task.CompletedTask;
|
}
|
|
#endregion
|
|
#region 资源清理方法
|
|
/// <summary>
|
/// 释放定时器资源
|
/// </summary>
|
private void DisposeTimers()
|
{
|
_heartbeatTimer?.Stop();
|
_heartbeatTimer?.Dispose();
|
_heartbeatTimer = null;
|
|
_dataPollingTimer?.Stop();
|
_dataPollingTimer?.Dispose();
|
_dataPollingTimer = null;
|
}
|
|
public void Dispose()
|
{
|
_cancellationTokenSource?.Cancel();
|
|
DisposeTimers();
|
Disconnect();
|
|
_modbusClient = null;
|
_databaseManager?.Dispose();
|
_databaseManager = null;
|
_cancellationTokenSource?.Dispose();
|
}
|
|
#endregion
|
|
#region 日志方法
|
|
private void LogInfo(string message)
|
{
|
Console.WriteLine($"[UNIVERSAL-INFO] {DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}");
|
}
|
|
private void LogWarning(string message)
|
{
|
Console.WriteLine($"[UNIVERSAL-WARN] {DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}");
|
}
|
|
private void LogError(string message)
|
{
|
Console.WriteLine($"[UNIVERSAL-ERROR] {DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}");
|
ErrorOccurred?.Invoke(this, message);
|
}
|
|
private void LogDebug(string message)
|
{
|
// 只在Debug模式下输出详细日志
|
#if DEBUG
|
Console.WriteLine($"[UNIVERSAL-DEBUG] {DateTime.Now:yyyy-MM-dd HH:mm:ss} - {message}");
|
#endif
|
}
|
|
#endregion
|
}
|
|
#region 通信统计类
|
|
/// <summary>
|
/// 通信统计信息
|
/// </summary>
|
public class CommunicationStats
|
{
|
/// <summary>
|
/// 连接尝试次数
|
/// </summary>
|
public long ConnectionAttempts { get; set; }
|
|
/// <summary>
|
/// 连接失败次数
|
/// </summary>
|
public long ConnectionFailures { get; set; }
|
|
/// <summary>
|
/// 发送的心跳包数量
|
/// </summary>
|
public long HeartbeatsSent { get; set; }
|
|
/// <summary>
|
/// 发送的确认信号数量
|
/// </summary>
|
public long ConfirmationsSent { get; set; }
|
|
/// <summary>
|
/// 成功读取次数
|
/// </summary>
|
public long SuccessfulReads { get; set; }
|
|
/// <summary>
|
/// 通信错误次数
|
/// </summary>
|
public long CommunicationErrors { get; set; }
|
|
/// <summary>
|
/// 最后连接时间
|
/// </summary>
|
public DateTime? LastConnectedTime { get; set; }
|
|
/// <summary>
|
/// 最后断开时间
|
/// </summary>
|
public DateTime? LastDisconnectedTime { get; set; }
|
|
/// <summary>
|
/// 获取连接成功率
|
/// </summary>
|
public double ConnectionSuccessRate =>
|
ConnectionAttempts > 0 ? (double)(ConnectionAttempts - ConnectionFailures) / ConnectionAttempts * 100 : 0;
|
|
/// <summary>
|
/// 获取连接成功率
|
/// </summary>
|
public double TotalConnectionAttempts => ConnectionAttempts;
|
|
/// <summary>
|
/// 获取成功连接数
|
/// </summary>
|
public double SuccessfulConnections => ConnectionAttempts - ConnectionFailures;
|
|
/// <summary>
|
/// 获取总读取数
|
/// </summary>
|
public double TotalDataReads => SuccessfulReads + CommunicationErrors;
|
|
/// <summary>
|
/// 获取数据读取成功率
|
/// </summary>
|
public double DataReadSuccessRate =>
|
TotalDataReads > 0 ? SuccessfulReads / TotalDataReads * 100 : 0;
|
|
/// <summary>
|
/// 获取总错误数
|
/// </summary>
|
public double TotalErrors => CommunicationErrors + ConnectionFailures;
|
|
/// <summary>
|
/// 平均响应时间（毫秒）
|
/// </summary>
|
public double AverageResponseTimeMs { get; set; } = 0;
|
|
/// <summary>
|
/// 最大响应时间（毫秒）
|
/// </summary>
|
public int MaxResponseTimeMs { get; set; } = 0;
|
|
/// <summary>
|
/// 最小响应时间（毫秒）
|
/// </summary>
|
public int MinResponseTimeMs { get; set; } = int.MaxValue;
|
|
/// <summary>
|
/// 获取统计摘要字符串
|
/// </summary>
|
public string GetSummary()
|
{
|
return $"连接: {ConnectionAttempts - ConnectionFailures}/{ConnectionAttempts} " +
|
$"({ConnectionSuccessRate:F1}%), " +
|
$"读取: {SuccessfulReads}, " +
|
$"错误: {CommunicationErrors}";
|
}
|
}
|
|
#endregion
|
}
|
