|
|
#region << 版 本 注 释 >>
|
|
|
|
|
|
/*--------------------------------------------------------------------
|
|
|
* 版权所有 (c) 2025 WenJY 保留所有权利。
|
|
|
* CLR版本：4.0.30319.42000
|
|
|
* 机器名称：Mr.Wen's MacBook Pro
|
|
|
* 命名空间：Sln.Imm.Daemon.Business
|
|
|
* 唯一标识：A7D0F481-367C-4C8F-9E27-416639212E62
|
|
|
*
|
|
|
* 创建者：WenJY
|
|
|
* 电子邮箱：
|
|
|
* 创建时间：2025-12-19 09:57:36
|
|
|
* 版本：V1.0.0
|
|
|
* 描述：
|
|
|
*
|
|
|
*--------------------------------------------------------------------
|
|
|
* 修改人：
|
|
|
* 时间：
|
|
|
* 修改说明：
|
|
|
*
|
|
|
* 版本：V1.0.0
|
|
|
*--------------------------------------------------------------------*/
|
|
|
|
|
|
#endregion << 版 本 注 释 >>
|
|
|
|
|
|
using Dm.util;
|
|
|
using Models;
|
|
|
using Newtonsoft.Json;
|
|
|
using Sln.Imm.Daemon.Cache;
|
|
|
using Sln.Imm.Daemon.Model.dao;
|
|
|
using Sln.Imm.Daemon.Model.dto;
|
|
|
using Sln.Imm.Daemon.Opc;
|
|
|
using Sln.Imm.Daemon.Opc.Impl;
|
|
|
using Sln.Imm.Daemon.Repository.service;
|
|
|
using Sln.Imm.Daemon.Repository.service.@base;
|
|
|
using Sln.Imm.Daemon.Serilog;
|
|
|
using SqlSugar;
|
|
|
using System.Collections.Concurrent;
|
|
|
using System.Diagnostics;
|
|
|
using System.Linq;
|
|
|
using System.Threading;
|
|
|
|
|
|
namespace Sln.Imm.Daemon.Business;
|
|
|
|
|
|
public class DeviceDataCollector : IDisposable
|
|
|
{
|
|
|
|
|
|
private readonly SerilogHelper _serilog;
|
|
|
|
|
|
private readonly SemaphoreSlim _semaphore; // 并发控制：限制同时采集的设备数（避免资源耗尽）
|
|
|
|
|
|
private CancellationTokenSource _cts; // 取消令牌：用于终止所有采集任务
|
|
|
|
|
|
private readonly int _collectIntervalMs; // 循环采集间隔（毫秒）
|
|
|
|
|
|
private readonly int _collectAlarmMs; // 循环采集三色灯间隔（毫秒）
|
|
|
|
|
|
private bool _isCollecting; // 是否正在采集（防止重复启动）
|
|
|
|
|
|
private readonly BaseDeviceInfoCacheService _cacheService;
|
|
|
|
|
|
private readonly IBaseDeviceParamService _paramAlarmService;
|
|
|
|
|
|
private readonly IBaseService<BaseDeviceParamVal> _paramValService;
|
|
|
|
|
|
private readonly IBaseDeviceAlarmValService _alarmValService;
|
|
|
|
|
|
private readonly IBaseRecordShutDownService _shutDownValService;
|
|
|
|
|
|
// 在类级别添加这个字典来存储每个设备的上一次状态
|
|
|
private readonly ConcurrentDictionary<string, DeviceAlarmState> _deviceLastAlarmStates =
|
|
|
new ConcurrentDictionary<string, DeviceAlarmState>();
|
|
|
|
|
|
// 新增：存储每个设备Alarm触发的状态
|
|
|
private readonly ConcurrentDictionary<string, AlarmTriggerState> _deviceAlarmTriggerStates =
|
|
|
new ConcurrentDictionary<string, AlarmTriggerState>();
|
|
|
|
|
|
// 新增：存储每个设备停机触发的状态
|
|
|
private readonly ConcurrentDictionary<string, ShutDownTriggerState> _deviceShutDownTriggerStates =
|
|
|
new ConcurrentDictionary<string, ShutDownTriggerState>();
|
|
|
|
|
|
private Dictionary<string, bool> _deviceAlarmStatus = new Dictionary<string, bool>();
|
|
|
private static readonly TimeSpan DisconnectTimeout = TimeSpan.FromSeconds(5);
|
|
|
private const int AlarmDeviceIntervalMs = 5000; // 每台设备采集完成后，等待 5 秒再采集下一台
|
|
|
private const int AlarmRoundIntervalMs = 10000; // 每轮采集完成后，固定等待 10 秒再开始下一轮
|
|
|
|
|
|
public DeviceDataCollector(SerilogHelper serilogHelper,
|
|
|
BaseDeviceInfoCacheService cacheService,
|
|
|
IBaseService<BaseDeviceParamVal> paramValService,
|
|
|
IBaseDeviceParamService paramAlarmService,
|
|
|
IBaseDeviceAlarmValService alarmValService,
|
|
|
IBaseRecordShutDownService shutDownValService,
|
|
|
int maxConcurrentDevices = 15)
|
|
|
{
|
|
|
_serilog = serilogHelper;
|
|
|
_cacheService = cacheService;
|
|
|
_paramValService = paramValService;
|
|
|
_paramAlarmService = paramAlarmService;
|
|
|
_alarmValService = alarmValService;
|
|
|
_shutDownValService = shutDownValService;
|
|
|
|
|
|
_semaphore = new SemaphoreSlim(maxConcurrentDevices, maxConcurrentDevices);
|
|
|
|
|
|
_cts = new CancellationTokenSource();
|
|
|
_collectIntervalMs = 1000 * 60 *10 ; //设备数据采集时间间隔
|
|
|
_isCollecting = false;
|
|
|
}
|
|
|
|
|
|
#region 私有类
|
|
|
/// <summary>
|
|
|
/// 设备报警状态结构
|
|
|
/// </summary>
|
|
|
private class DeviceAlarmState
|
|
|
{
|
|
|
public bool LastRunning { get; set; }
|
|
|
public bool LastAlarm { get; set; }
|
|
|
public bool LastStopped { get; set; }
|
|
|
public DateTime LastUpdateTime { get; set; }
|
|
|
public bool IsFirstTime { get; set; } = true; // 标记是否为第一次采集
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Alarm触发状态结构
|
|
|
/// </summary>
|
|
|
private class AlarmTriggerState
|
|
|
{
|
|
|
public bool LastAlarmValue { get; set; }
|
|
|
public long? AlarmRecordId { get; set; } // 存储插入的Alarm记录ID，用于后续更新
|
|
|
public DateTime LastTriggerTime { get; set; }
|
|
|
public bool IsAlarmActive { get; set; } // 标记当前是否有活跃的Alarm记录
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 停机触发状态结构
|
|
|
/// </summary>
|
|
|
private class ShutDownTriggerState
|
|
|
{
|
|
|
public bool LastStoppedValue { get; set; }
|
|
|
public DateTime LastTriggerTime { get; set; }
|
|
|
public bool IsShutDownActive { get; set; } // 标记当前是否有活跃的停机记录
|
|
|
}
|
|
|
#endregion
|
|
|
|
|
|
#region 循环采集
|
|
|
|
|
|
/// <summary>
|
|
|
/// 启动15设备并行循环采集
|
|
|
/// </summary>
|
|
|
/// <param name="devices">15台设备列表</param>
|
|
|
/// <param name="loopCount">循环次数（-1=无限）</param>
|
|
|
public async Task StartParallelLoopCollectAsync(int loopCount = -1)
|
|
|
{
|
|
|
if (_isCollecting)
|
|
|
{
|
|
|
Console.WriteLine($"[{DateTime.Now}] 并行采集已在运行，无需重复启动");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
_isCollecting = true;
|
|
|
int currentLoop = 0;
|
|
|
|
|
|
try
|
|
|
{
|
|
|
while (!_cts.Token.IsCancellationRequested)
|
|
|
{
|
|
|
// 达到指定循环次数退出
|
|
|
if (loopCount > 0 && currentLoop >= loopCount)
|
|
|
{
|
|
|
Console.WriteLine($"[{DateTime.Now}] 完成指定循环次数({loopCount}次)，停止采集");
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
currentLoop++;
|
|
|
Console.WriteLine($"\n========== 第 {currentLoop} 轮并行采集开始 [{DateTime.Now}] ==========");
|
|
|
|
|
|
// 记录本轮开始时间（保证10秒间隔精准）
|
|
|
var roundStartTime = DateTime.Now;
|
|
|
|
|
|
// 核心：并行采集15台设备（真正同时启动）
|
|
|
var collectResult = await CollectDevicesInParallelAsync();
|
|
|
|
|
|
// 输出本轮结果
|
|
|
OutputCollectResult(collectResult);
|
|
|
|
|
|
// 计算耗时，补足10秒间隔
|
|
|
var roundCost = (DateTime.Now - roundStartTime).TotalMilliseconds;
|
|
|
var waitMs = _collectIntervalMs - roundCost;
|
|
|
|
|
|
if (waitMs > 0)
|
|
|
{
|
|
|
Console.WriteLine($"\n第 {currentLoop} 轮采集完成（耗时{roundCost:F0}ms），等待{waitMs:F0}ms后下一轮");
|
|
|
await Task.Delay((int)waitMs, _cts.Token);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Console.WriteLine($"\n第 {currentLoop} 轮采集超时（耗时{roundCost:F0}ms），立即开始下一轮");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
catch (OperationCanceledException)
|
|
|
{
|
|
|
Console.WriteLine($"[{DateTime.Now}] 并行采集已手动终止");
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
Console.WriteLine($"[{DateTime.Now}] 并行采集异常：{ex.Message}", ex);
|
|
|
}
|
|
|
finally
|
|
|
{
|
|
|
_isCollecting = false;
|
|
|
Console.WriteLine($"[{DateTime.Now}] 并行采集循环结束");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 启动报警信息监控循环
|
|
|
/// </summary>
|
|
|
public async Task StartAlarmMonitorLoopSimpleAsync()
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
Console.WriteLine($"[{DateTime.Now}] 报警监控开始（每轮完成后固定等待 {AlarmRoundIntervalMs / 1000} 秒）");
|
|
|
|
|
|
while (!_cts.Token.IsCancellationRequested)
|
|
|
{
|
|
|
// 记录本轮开始时间
|
|
|
var startTime = DateTime.Now;
|
|
|
|
|
|
try
|
|
|
{
|
|
|
// 执行报警采集
|
|
|
await CollectDevicesAlarmAsync();
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
Console.WriteLine($"[报警监控] 采集异常: {ex.Message}");
|
|
|
_serilog.Error($"报警监控采集异常", ex);
|
|
|
}
|
|
|
|
|
|
// 计算耗时
|
|
|
var elapsedMs = (DateTime.Now - startTime).TotalMilliseconds;
|
|
|
|
|
|
// 固定间隔：每轮采集结束后等待 30 秒再开始下一轮（不再做“精准补齐间隔”）
|
|
|
Console.WriteLine($"[报警监控] 本轮耗时 {elapsedMs:F0}ms，等待 {AlarmRoundIntervalMs}ms 后下一轮");
|
|
|
await Task.Delay(AlarmRoundIntervalMs, _cts.Token);
|
|
|
}
|
|
|
}
|
|
|
catch (OperationCanceledException)
|
|
|
{
|
|
|
Console.WriteLine($"[{DateTime.Now}] 报警监控已停止");
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
Console.WriteLine($"[{DateTime.Now}] 报警监控异常：{ex.Message}");
|
|
|
_serilog.Error($"报警监控异常", ex);
|
|
|
}
|
|
|
finally
|
|
|
{
|
|
|
Console.WriteLine($"[{DateTime.Now}] 报警监控结束");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 输出采集结果
|
|
|
/// </summary>
|
|
|
private void OutputCollectResult(Dictionary<string, object> collectResult)
|
|
|
{
|
|
|
Console.WriteLine($"\n[{DateTime.Now}] 本轮采集结果汇总：");
|
|
|
foreach (var kvp in collectResult)
|
|
|
{
|
|
|
var deviceAddress = kvp.Key;
|
|
|
var result = kvp.Value;
|
|
|
|
|
|
if (result is Exception ex)
|
|
|
{
|
|
|
Console.WriteLine($" {deviceAddress}：失败 - {ex.Message}");
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Console.WriteLine($" {deviceAddress}：成功 - {JsonConvert.SerializeObject(result)}");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
public async Task<Dictionary<string, object>> CollectDevicesInParallelAsync()
|
|
|
{
|
|
|
var deviceInfos = await _cacheService.GetValueAsync("BaseDeviceInfoCache");
|
|
|
|
|
|
if (deviceInfos == null || deviceInfos.Count == 0)
|
|
|
throw new ArgumentException("设备列表不能为空", nameof(deviceInfos));
|
|
|
|
|
|
var resultDict = new Dictionary<string, object>();
|
|
|
var taskList = new List<Task>();
|
|
|
|
|
|
foreach (var item in deviceInfos)
|
|
|
{
|
|
|
// 每个设备创建独立的采集任务
|
|
|
taskList.Add(CollectSingleDeviceParallelAsync(item, resultDict, _cts.Token));
|
|
|
}
|
|
|
|
|
|
// 等待所有任务完成（无论成功/失败）
|
|
|
await Task.WhenAll(taskList);
|
|
|
|
|
|
return resultDict;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 采集三色灯报警：顺序循环采集每台设备，每台采集完成后等待 10 秒再采集下一台；一轮完成后间隔时间不变。
|
|
|
/// </summary>
|
|
|
public async Task<Dictionary<string, object>> CollectDevicesAlarmAsync()
|
|
|
{
|
|
|
var deviceInfos = await _cacheService.GetValueAsync("BaseDeviceInfoCache");
|
|
|
|
|
|
if (deviceInfos == null || deviceInfos.Count == 0)
|
|
|
{
|
|
|
Console.WriteLine($"[报警监控] 无设备信息");
|
|
|
throw new ArgumentException("设备列表不能为空", nameof(deviceInfos));
|
|
|
}
|
|
|
|
|
|
Console.WriteLine($"[报警监控] 开始采集 {deviceInfos.Count} 台设备（顺序采集，每台间隔 {AlarmDeviceIntervalMs / 1000} 秒）");
|
|
|
var resultDict = new Dictionary<string, object>();
|
|
|
|
|
|
for (var i = 0; i < deviceInfos.Count; i++)
|
|
|
{
|
|
|
if (_cts.Token.IsCancellationRequested)
|
|
|
break;
|
|
|
|
|
|
var device = deviceInfos[i];
|
|
|
await CollectOneDeviceAlarmAsync(device, resultDict, _cts.Token);
|
|
|
|
|
|
// 每台设备采集完成后等待 10 秒再采集下一台（最后一台后不等待）
|
|
|
if (i < deviceInfos.Count - 1)
|
|
|
{
|
|
|
await Task.Delay(AlarmDeviceIntervalMs, _cts.Token);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Console.WriteLine($"[报警监控] 本轮采集完成（共 {deviceInfos.Count} 台设备，结果数: {resultDict.Count}）");
|
|
|
return resultDict;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 顺序模式下单台设备报警采集（无信号量，由上层循环调用）。
|
|
|
/// </summary>
|
|
|
private async Task CollectOneDeviceAlarmAsync(
|
|
|
BaseDeviceInfo device,
|
|
|
Dictionary<string, object> resultDict,
|
|
|
CancellationToken cancellationToken)
|
|
|
{
|
|
|
IOpcService opcUa = null;
|
|
|
List<OpcNode> opcItemValues = null;
|
|
|
|
|
|
try
|
|
|
{
|
|
|
if (device.deviceFacture.Contains("伊之密"))
|
|
|
{
|
|
|
opcUa = new OpcUaService();
|
|
|
}
|
|
|
else if (device.deviceFacture.Contains("老设备"))
|
|
|
{
|
|
|
opcUa = new OpcDaService();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
bool connectResult = await opcUa.ConnectAsync(device.networkAddress);
|
|
|
if (!connectResult)
|
|
|
{
|
|
|
Console.WriteLine($"报警信息 - [{DateTime.Now}] 设备 {device.deviceName} 连接失败");
|
|
|
resultDict[device.networkAddress] = new Exception($"设备 {device.deviceName} 连接失败");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
_serilog.Info($"报警信息开始采集{device.deviceName}；");
|
|
|
|
|
|
opcItemValues = await ReadAlarm(device, opcUa);
|
|
|
|
|
|
if (opcItemValues == null || opcItemValues.Count == 0)
|
|
|
{
|
|
|
Console.WriteLine($"报警信息 - [{DateTime.Now}] {device.deviceName} - 未读取到报警点位");
|
|
|
resultDict[device.networkAddress] = opcItemValues ?? new List<OpcNode>();
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (HasAlarmStateChanged(device, opcItemValues))
|
|
|
{
|
|
|
_serilog.Info($"{device.deviceName}三色灯状态改变");
|
|
|
try
|
|
|
{
|
|
|
SaveParam(device, opcItemValues, out List<BaseDeviceParamVal> paramValues);
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
_serilog.Error($"设备 {device.deviceName} 保存参数失败", ex);
|
|
|
}
|
|
|
}
|
|
|
//报警处理
|
|
|
try
|
|
|
{
|
|
|
int should = ShouldRecordAlarmTrue(device, opcItemValues);
|
|
|
if (should == 1)
|
|
|
{
|
|
|
_serilog.Info($"{device.deviceName}报警触发");
|
|
|
BaseDeviceAlarmVal paramVal = new BaseDeviceAlarmVal
|
|
|
{
|
|
|
DEVICE_ID = device.objid,
|
|
|
ALARM_BEGIN_TIME = DateTime.Now,
|
|
|
CONTINUE_TIME = 0
|
|
|
};
|
|
|
_alarmValService.Insert(paramVal);
|
|
|
}
|
|
|
else if (should == 2)
|
|
|
{
|
|
|
_serilog.Info($"{device.deviceName}报警恢复");
|
|
|
_alarmValService.UpdateAlarmVal(device.objid);
|
|
|
}
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
_serilog.Error($"设备 {device.deviceName} 报警记录操作失败", ex);
|
|
|
}
|
|
|
|
|
|
// 处理停机记录
|
|
|
try
|
|
|
{
|
|
|
int shutDownShould = ShouldRecordShutDownTrue(device, opcItemValues);
|
|
|
if (shutDownShould == 1)
|
|
|
{
|
|
|
_serilog.Info($"{device.deviceName}停机触发");
|
|
|
BaseRecordShutDown shutDownVal = new BaseRecordShutDown
|
|
|
{
|
|
|
MACHINE_ID = device.objid,
|
|
|
SHUT_TYPE_ID = 1,
|
|
|
SHUT_REASON_ID = 1,
|
|
|
SHUT_REASON = "R001",
|
|
|
SHUT_BEGIN_TIME = DateTime.Now,
|
|
|
SHUT_TIME = 0,
|
|
|
DOWNTIME_FLAG = "0",
|
|
|
ACTIVE_FLAG = "1"
|
|
|
};
|
|
|
_shutDownValService.Insert(shutDownVal);
|
|
|
}
|
|
|
else if (shutDownShould == 2)
|
|
|
{
|
|
|
_serilog.Info($"{device.deviceName}停机恢复");
|
|
|
_shutDownValService.UpdateShutDownVal(device.objid);
|
|
|
}
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
_serilog.Error($"设备 {device.deviceName} 停机记录操作失败", ex);
|
|
|
}
|
|
|
|
|
|
resultDict[device.networkAddress] = opcItemValues;
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
_serilog.Error($"设备 {device.deviceName} 三色灯采集异常", ex);
|
|
|
resultDict[device.networkAddress] = new Exception($"设备 {device.deviceName} 三色灯采集异常：{ex.Message}", ex);
|
|
|
}
|
|
|
finally
|
|
|
{
|
|
|
if (opcUa != null)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
await SafeDisconnectAsync(opcUa, device.deviceName).ConfigureAwait(false);
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
_serilog.Error($"设备 {device.deviceName} 断开连接失败", ex);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private async Task CollectSingleDeviceParallelAsync(BaseDeviceInfo device, Dictionary<string, object> resultDict,
|
|
|
CancellationToken cancellationToken)
|
|
|
{
|
|
|
await _semaphore.WaitAsync(cancellationToken);
|
|
|
List<OpcNode> opcItemValues = null;
|
|
|
|
|
|
IOpcService opcUa = null;
|
|
|
try
|
|
|
{
|
|
|
if (device.deviceFacture.Contains("伊之密"))
|
|
|
{
|
|
|
opcUa =new OpcUaService();
|
|
|
}
|
|
|
else if(device.deviceFacture.Contains("老设备"))
|
|
|
{
|
|
|
opcUa =new OpcDaService();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
Console.WriteLine($"[{DateTime.Now}] {device.deviceName} - 开始连接并采集");
|
|
|
bool connectResult = await opcUa.ConnectAsync(device.networkAddress);
|
|
|
if (!connectResult)
|
|
|
{
|
|
|
resultDict[device.networkAddress] = new Exception($"设备 {device.deviceName} 连接失败");
|
|
|
Console.WriteLine($"[{DateTime.Now}] 设备 {device.deviceName} 连接失败");
|
|
|
return;
|
|
|
}
|
|
|
Console.WriteLine($"[{DateTime.Now}] 设备 {device.deviceName} 连接成功");
|
|
|
|
|
|
// 2. 读取设备数据（你封装的ReadParam方法）
|
|
|
//Console.WriteLine($"[{DateTime.Now}] 开始读取设备 {device.deviceName} 数据");
|
|
|
_serilog.Info($"开始采集{device.deviceName}；");
|
|
|
opcItemValues = await ReadParam(device, opcUa);
|
|
|
|
|
|
this.SaveParam(device, opcItemValues, out List<BaseDeviceParamVal> paramValues);
|
|
|
|
|
|
_serilog.Info($"{device.deviceName}数据采集完成：{JsonConvert.SerializeObject(opcItemValues)}");
|
|
|
|
|
|
//Console.WriteLine($"[{DateTime.Now}] 设备 {device.deviceName} 数据读取完成");
|
|
|
|
|
|
// 3. 存储读取结果
|
|
|
resultDict[device.networkAddress] = opcItemValues;
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
// 捕获采集过程中的异常
|
|
|
resultDict[device.networkAddress] = new Exception($"设备 {device.deviceName} 采集异常：{ex.Message}", ex);
|
|
|
Console.WriteLine($"[{DateTime.Now}] 设备 {device.deviceName} 采集异常：{ex.Message}");
|
|
|
}
|
|
|
finally
|
|
|
{
|
|
|
// 无论成功/失败，都断开设备连接（释放资源）
|
|
|
try
|
|
|
{
|
|
|
await SafeDisconnectAsync(opcUa, device.deviceName).ConfigureAwait(false);
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
Console.WriteLine($"[{DateTime.Now}] 设备 {device.deviceName} 断开连接失败：{ex.Message}");
|
|
|
}
|
|
|
|
|
|
// 释放信号量（允许下一个设备采集）
|
|
|
_semaphore.Release();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private static async Task SafeDisconnectAsync(IOpcService opcUa, string deviceName)
|
|
|
{
|
|
|
if (opcUa == null) return;
|
|
|
|
|
|
Console.WriteLine($"[{DateTime.Now}] 设备 {deviceName} 开始断开连接...");
|
|
|
|
|
|
var disconnectTask = opcUa.DisconnectAsync();
|
|
|
var finished = await Task.WhenAny(disconnectTask, Task.Delay(DisconnectTimeout)).ConfigureAwait(false);
|
|
|
|
|
|
if (finished != disconnectTask)
|
|
|
{
|
|
|
Console.WriteLine($"[{DateTime.Now}] 设备 {deviceName} 断开连接超时(>{DisconnectTimeout.TotalSeconds:F0}s)，跳过等待以避免阻塞");
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
await disconnectTask.ConfigureAwait(false);
|
|
|
Console.WriteLine($"[{DateTime.Now}] 设备 {deviceName} 已断开连接");
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
/// <summary>
|
|
|
/// 读取设备参数
|
|
|
/// </summary>
|
|
|
/// <param name="device"></param>
|
|
|
public async Task<List<OpcNode>> ReadParam(BaseDeviceInfo device,IOpcService opcUa)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
if (device == null)
|
|
|
{
|
|
|
throw new ArgumentNullException($"设备信息不允许为空");
|
|
|
}
|
|
|
|
|
|
List<string> deviceParams = device.deviceParams.Select(x => x.paramAddr).ToList();
|
|
|
|
|
|
Stopwatch sw = Stopwatch.StartNew();
|
|
|
|
|
|
List<OpcNode> infos = await opcUa.ReadNodeAsync(deviceParams);
|
|
|
|
|
|
sw.Stop();
|
|
|
|
|
|
_serilog.Info($"opc读取耗时{sw.ElapsedMilliseconds.ToString()}");
|
|
|
|
|
|
return infos;
|
|
|
|
|
|
}
|
|
|
catch (Exception e)
|
|
|
{
|
|
|
throw new InvalidOperationException($"设备参数读取异常:{e.Message}");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 读取设备报警
|
|
|
/// </summary>
|
|
|
/// <param name="device"></param>
|
|
|
/// <param name="opcUa"></param>
|
|
|
/// <returns></returns>
|
|
|
public async Task<List<OpcNode>> ReadAlarm(BaseDeviceInfo device, IOpcService opcUa)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
if (device == null)
|
|
|
{
|
|
|
throw new ArgumentNullException($"设备信息不允许为空");
|
|
|
}
|
|
|
if (opcUa == null)
|
|
|
{
|
|
|
throw new ArgumentNullException($"OPC服务不允许为空");
|
|
|
}
|
|
|
List<string> deviceParams = new List<string>();
|
|
|
List<BaseDeviceParam> paramList = _paramAlarmService.GetDeviceAlarmParams(device);
|
|
|
if (paramList == null || paramList.Count == 0)
|
|
|
return null;
|
|
|
|
|
|
foreach (BaseDeviceParam param in paramList)
|
|
|
{
|
|
|
if (string.IsNullOrEmpty(param?.paramAddr))
|
|
|
continue;
|
|
|
deviceParams.Add(param.paramAddr);
|
|
|
}
|
|
|
if (deviceParams.Count == 0)
|
|
|
return null;
|
|
|
|
|
|
List<OpcNode> infos = await opcUa.ReadNodeAsync(deviceParams);
|
|
|
return infos;
|
|
|
}
|
|
|
catch (Exception e)
|
|
|
{
|
|
|
throw new InvalidOperationException($"设备参数读取异常:{e.Message}", e);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 保存设备参数值到数据库
|
|
|
/// </summary>
|
|
|
/// <param name="device">设备信息</param>
|
|
|
/// <param name="opcItemValues">OPC节点值列表</param>
|
|
|
/// <param name="paramValues">输出参数值DTO列表</param>
|
|
|
public void SaveParam(BaseDeviceInfo device, List<OpcNode> opcItemValues,
|
|
|
out List<BaseDeviceParamVal> paramValues)
|
|
|
{
|
|
|
paramValues = new List<BaseDeviceParamVal>();
|
|
|
try
|
|
|
{
|
|
|
foreach (OpcNode opcItem in opcItemValues)
|
|
|
{
|
|
|
BaseDeviceParamVal deviceParamVal = new BaseDeviceParamVal();
|
|
|
|
|
|
var paramInfo = device.deviceParams.Where(x => x.paramAddr == opcItem.NodeId).FirstOrDefault();
|
|
|
if (paramInfo != null)
|
|
|
{
|
|
|
deviceParamVal.paramCode = paramInfo.paramCode;
|
|
|
deviceParamVal.paramName = paramInfo.paramName;
|
|
|
}
|
|
|
deviceParamVal.deviceCode = device.deviceCode;
|
|
|
deviceParamVal.deviceId = device.objid;
|
|
|
if(opcItem.Value != null)
|
|
|
{
|
|
|
deviceParamVal.paramValue = opcItem.Value.ToString();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
deviceParamVal.paramValue = "无";
|
|
|
}
|
|
|
|
|
|
deviceParamVal.paramType = opcItem.DataType;
|
|
|
deviceParamVal.collectTime = DateTime.Now;
|
|
|
deviceParamVal.recordTime = DateTime.Now;
|
|
|
|
|
|
paramValues.Add(deviceParamVal);
|
|
|
}
|
|
|
|
|
|
var isRes = _paramValService.Insert(paramValues);
|
|
|
if (isRes)
|
|
|
{
|
|
|
_serilog.Info(($"{device.deviceName} 设备参数保存成功"));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
_serilog.Info(($"{device.deviceName} 设备参数保存失败"));
|
|
|
}
|
|
|
}catch (Exception e)
|
|
|
{
|
|
|
_serilog.Error($"DevicedataCollection报错", e);
|
|
|
throw new InvalidOperationException($"设备参数保存异常:{e.Message}");
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 检查报警状态是否有变化
|
|
|
/// </summary>
|
|
|
/// <param name="device"></param>
|
|
|
/// <param name="currentOpcItemValues"></param>
|
|
|
/// <returns></returns>
|
|
|
private bool HasAlarmStateChanged(BaseDeviceInfo device, List<OpcNode> currentOpcItemValues)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
// 1. 从当前数据中提取三个关键报警点位
|
|
|
OpcNode runningNode = null;
|
|
|
OpcNode alarmNode = null;
|
|
|
OpcNode stoppedNode = null;
|
|
|
|
|
|
foreach (var node in currentOpcItemValues)
|
|
|
{
|
|
|
if (node.NodeId.Contains("Running", StringComparison.OrdinalIgnoreCase))
|
|
|
runningNode = node;
|
|
|
else if (node.NodeId.Contains("Alarm", StringComparison.OrdinalIgnoreCase))
|
|
|
alarmNode = node;
|
|
|
else if (node.NodeId.Contains("Stopped", StringComparison.OrdinalIgnoreCase))
|
|
|
stoppedNode = node;
|
|
|
}
|
|
|
|
|
|
// 如果三个点位没有全部找到，认为数据不完整，不进行处理
|
|
|
if (runningNode == null || alarmNode == null || stoppedNode == null)
|
|
|
{
|
|
|
Console.WriteLine($"报警信息 - [{DateTime.Now}] 设备 {device.deviceName} - 未找到完整的报警点位(Running/Alarm/Stopped)");
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 2. 解析当前状态值
|
|
|
bool currentRunning = GetBoolValue(runningNode.Value);
|
|
|
bool currentAlarm = GetBoolValue(alarmNode.Value);
|
|
|
bool currentStopped = GetBoolValue(stoppedNode.Value);
|
|
|
|
|
|
// 3. 获取或创建该设备的上一次状态记录
|
|
|
string deviceKey = device.objid.ToString(); // 使用设备ID作为字典键
|
|
|
bool hasChanged = false;
|
|
|
|
|
|
// 使用线程安全的方式获取或创建设备状态
|
|
|
_deviceLastAlarmStates.AddOrUpdate(deviceKey,
|
|
|
// 如果设备第一次采集，创建新状态记录
|
|
|
(key) =>
|
|
|
{
|
|
|
// 第一次采集，创建初始状态记录
|
|
|
var newState = new DeviceAlarmState
|
|
|
{
|
|
|
LastRunning = currentRunning,
|
|
|
LastAlarm = currentAlarm,
|
|
|
LastStopped = currentStopped,
|
|
|
LastUpdateTime = DateTime.Now,
|
|
|
IsFirstTime = false // 标记为已初始化
|
|
|
};
|
|
|
|
|
|
Console.WriteLine($"报警信息 - [{DateTime.Now}] 设备 {device.deviceName} - 首次采集，创建初始状态记录");
|
|
|
hasChanged = true; // 第一次采集总是保存
|
|
|
return newState;
|
|
|
},
|
|
|
// 如果设备已有状态记录，进行比较和更新
|
|
|
(key, existingState) =>
|
|
|
{
|
|
|
// 检查状态是否有变化
|
|
|
bool runningChanged = existingState.LastRunning != currentRunning;
|
|
|
bool alarmChanged = existingState.LastAlarm != currentAlarm;
|
|
|
bool stoppedChanged = existingState.LastStopped != currentStopped;
|
|
|
|
|
|
// 只要有一个状态发生变化，就认为有变化
|
|
|
hasChanged = runningChanged || alarmChanged || stoppedChanged;
|
|
|
|
|
|
if (hasChanged)
|
|
|
{
|
|
|
// 记录变化详情
|
|
|
Console.WriteLine($"报警信息 - [{DateTime.Now}] 设备 {device.deviceName} - 状态变化: " +
|
|
|
$"R[{existingState.LastRunning}->{currentRunning}], " +
|
|
|
$"A[{existingState.LastAlarm}->{currentAlarm}], " +
|
|
|
$"S[{existingState.LastStopped}->{currentStopped}]");
|
|
|
|
|
|
// 更新为最新状态
|
|
|
existingState.LastRunning = currentRunning;
|
|
|
existingState.LastAlarm = currentAlarm;
|
|
|
existingState.LastStopped = currentStopped;
|
|
|
existingState.LastUpdateTime = DateTime.Now;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Console.WriteLine($"报警信息 - [{DateTime.Now}] 设备 {device.deviceName} - 状态无变化: " +
|
|
|
$"R[{currentRunning}], A[{currentAlarm}], S[{currentStopped}]");
|
|
|
}
|
|
|
|
|
|
return existingState;
|
|
|
});
|
|
|
|
|
|
return hasChanged;
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
Console.WriteLine($"报警信息 - [{DateTime.Now}] 设备 {device.deviceName} - 检查状态变化异常: {ex.Message}");
|
|
|
_serilog.Error($"设备 {device.deviceName} 检查状态变化异常", ex);
|
|
|
return false; // 出现异常时，不保存
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 检查是否需要记录Alarm为true的情况（新增逻辑）
|
|
|
/// </summary>
|
|
|
/// <param name="device">设备信息</param>
|
|
|
/// <param name="currentOpcItemValues">当前采集的OPC点位值</param>
|
|
|
/// <returns>true表示需要记录Alarm为true，false表示不需要记录</returns>
|
|
|
private int ShouldRecordAlarmTrue(BaseDeviceInfo device, List<OpcNode> currentOpcItemValues)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
// 1. 从当前数据中提取Alarm点位
|
|
|
OpcNode alarmNode = null;
|
|
|
|
|
|
foreach (var node in currentOpcItemValues)
|
|
|
{
|
|
|
if (node.NodeId.Contains("Alarm", StringComparison.OrdinalIgnoreCase))
|
|
|
{
|
|
|
alarmNode = node;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果Alarm点位没有找到，不进行处理
|
|
|
if (alarmNode == null)
|
|
|
{
|
|
|
Console.WriteLine($"Alarm记录 - [{DateTime.Now}] 设备 {device.deviceName} - 未找到Alarm点位");
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
// 2. 解析当前Alarm状态值
|
|
|
bool currentAlarm = GetBoolValue(alarmNode.Value);
|
|
|
|
|
|
// 3. 获取设备当前的Alarm触发状态
|
|
|
string deviceKey = device.objid.ToString();
|
|
|
|
|
|
// 使用线程安全的方式获取或创建设备Alarm触发状态
|
|
|
int operationType = 0; // 0-无操作，1-插入，2-更新
|
|
|
|
|
|
_deviceAlarmTriggerStates.AddOrUpdate(deviceKey,
|
|
|
// 如果设备第一次检测到Alarm，创建新状态记录
|
|
|
(key) =>
|
|
|
{
|
|
|
// 第一次检测到Alarm，创建初始状态记录
|
|
|
var newState = new AlarmTriggerState
|
|
|
{
|
|
|
LastAlarmValue = currentAlarm,
|
|
|
AlarmRecordId = null,
|
|
|
LastTriggerTime = DateTime.Now,
|
|
|
IsAlarmActive = false
|
|
|
};
|
|
|
|
|
|
// 如果是第一次采集且Alarm为true，需要插入记录
|
|
|
if (currentAlarm)
|
|
|
{
|
|
|
Console.WriteLine($"Alarm记录 - [{DateTime.Now}] 设备 {device.deviceName} - 首次检测到Alarm为true，需要插入记录");
|
|
|
operationType = 1; // 需要插入记录
|
|
|
newState.IsAlarmActive = true; // 标记有活跃的Alarm记录
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Console.WriteLine($"Alarm记录 - [{DateTime.Now}] 设备 {device.deviceName} - 首次检测到Alarm为false，无需操作");
|
|
|
}
|
|
|
|
|
|
return newState;
|
|
|
},
|
|
|
// 如果设备已有Alarm触发状态记录，进行比较
|
|
|
(key, existingState) =>
|
|
|
{
|
|
|
// 检查状态变化
|
|
|
if (existingState.LastAlarmValue == false && currentAlarm == true)
|
|
|
{
|
|
|
// 1: Alarm从false变为true，需要插入记录
|
|
|
operationType = 1; // 需要插入记录
|
|
|
existingState.IsAlarmActive = true; // 标记有活跃的Alarm记录
|
|
|
existingState.AlarmRecordId = null; // 重置记录ID，将在插入后设置
|
|
|
}
|
|
|
else if (existingState.LastAlarmValue == true && currentAlarm == false)
|
|
|
{
|
|
|
// 2: Alarm从true变为false，需要更新记录
|
|
|
if (existingState.IsAlarmActive)
|
|
|
{
|
|
|
operationType = 2; // 需要更新记录
|
|
|
existingState.IsAlarmActive = false; // 标记Alarm记录已结束
|
|
|
}
|
|
|
}
|
|
|
else if (existingState.LastAlarmValue == true && currentAlarm == true)
|
|
|
{
|
|
|
// 3.Alarm持续为true，忽略
|
|
|
operationType = 0;
|
|
|
}
|
|
|
else // existingState.LastAlarmValue == false && currentAlarm == false
|
|
|
{
|
|
|
// 4.Alarm持续为false，忽略
|
|
|
operationType = 0;
|
|
|
}
|
|
|
|
|
|
// 更新状态
|
|
|
existingState.LastAlarmValue = currentAlarm;
|
|
|
existingState.LastTriggerTime = DateTime.Now;
|
|
|
|
|
|
return existingState;
|
|
|
});
|
|
|
|
|
|
return operationType;
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
Console.WriteLine($"Alarm记录 - [{DateTime.Now}] 设备 {device.deviceName} - 检查Alarm记录异常: {ex.Message}");
|
|
|
_serilog.Error($"设备 {device.deviceName} 检查Alarm记录异常", ex);
|
|
|
return 0; // 出现异常时，不操作
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 检查是否需要记录停机为true的情况
|
|
|
/// </summary>
|
|
|
/// <param name="device">设备信息</param>
|
|
|
/// <param name="currentOpcItemValues">当前采集的OPC点位值</param>
|
|
|
/// <returns>0-无操作，1-插入，2-更新</returns>
|
|
|
private int ShouldRecordShutDownTrue(BaseDeviceInfo device, List<OpcNode> currentOpcItemValues)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
// 1. 从当前数据中提取Stopped点位
|
|
|
OpcNode stoppedNode = null;
|
|
|
|
|
|
foreach (var node in currentOpcItemValues)
|
|
|
{
|
|
|
if (node.NodeId.Contains("Stopped", StringComparison.OrdinalIgnoreCase))
|
|
|
{
|
|
|
stoppedNode = node;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果Stopped点位没有找到，不进行处理
|
|
|
if (stoppedNode == null)
|
|
|
{
|
|
|
Console.WriteLine($"停机记录 - [{DateTime.Now}] 设备 {device.deviceName} - 未找到Stopped点位");
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
// 2. 解析当前停机状态值
|
|
|
bool currentStopped = GetBoolValue(stoppedNode.Value);
|
|
|
|
|
|
// 3. 获取设备当前的停机触发状态
|
|
|
string deviceKey = device.objid.ToString();
|
|
|
|
|
|
// 使用线程安全的方式获取或创建设备停机触发状态
|
|
|
int operationType = 0; // 0-无操作，1-插入，2-更新
|
|
|
|
|
|
_deviceShutDownTriggerStates.AddOrUpdate(deviceKey,
|
|
|
// 如果设备第一次检测到停机，创建新状态记录
|
|
|
(key) =>
|
|
|
{
|
|
|
// 第一次检测到停机，创建初始状态记录
|
|
|
var newState = new ShutDownTriggerState
|
|
|
{
|
|
|
LastStoppedValue = currentStopped,
|
|
|
LastTriggerTime = DateTime.Now,
|
|
|
IsShutDownActive = false
|
|
|
};
|
|
|
|
|
|
// 如果是第一次采集且停机为true，需要插入记录
|
|
|
if (currentStopped)
|
|
|
{
|
|
|
Console.WriteLine($"停机记录 - [{DateTime.Now}] 设备 {device.deviceName} - 首次检测到停机为true，需要插入记录");
|
|
|
operationType = 1; // 需要插入记录
|
|
|
newState.IsShutDownActive = true; // 标记有活跃的停机记录
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Console.WriteLine($"停机记录 - [{DateTime.Now}] 设备 {device.deviceName} - 首次检测到停机为false，无需操作");
|
|
|
}
|
|
|
|
|
|
return newState;
|
|
|
},
|
|
|
// 如果设备已有停机触发状态记录，进行比较
|
|
|
(key, existingState) =>
|
|
|
{
|
|
|
// 检查状态变化
|
|
|
if (existingState.LastStoppedValue == false && currentStopped == true)
|
|
|
{
|
|
|
// 1: 停机从false变为true，需要插入记录
|
|
|
operationType = 1; // 需要插入记录
|
|
|
existingState.IsShutDownActive = true; // 标记有活跃的停机记录
|
|
|
}
|
|
|
else if (existingState.LastStoppedValue == true && currentStopped == false)
|
|
|
{
|
|
|
// 2: 停机从true变为false，需要更新记录
|
|
|
if (existingState.IsShutDownActive)
|
|
|
{
|
|
|
operationType = 2; // 需要更新记录
|
|
|
existingState.IsShutDownActive = false; // 标记停机记录已结束
|
|
|
}
|
|
|
}
|
|
|
else if (existingState.LastStoppedValue == true && currentStopped == true)
|
|
|
{
|
|
|
// 3. 停机持续为true，忽略
|
|
|
operationType = 0;
|
|
|
}
|
|
|
else // existingState.LastStoppedValue == false && currentStopped == false
|
|
|
{
|
|
|
// 4. 停机持续为false，忽略
|
|
|
operationType = 0;
|
|
|
}
|
|
|
|
|
|
// 更新状态
|
|
|
existingState.LastStoppedValue = currentStopped;
|
|
|
existingState.LastTriggerTime = DateTime.Now;
|
|
|
|
|
|
return existingState;
|
|
|
});
|
|
|
|
|
|
return operationType;
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
Console.WriteLine($"停机记录 - [{DateTime.Now}] 设备 {device.deviceName} - 检查停机记录异常: {ex.Message}");
|
|
|
_serilog.Error($"设备 {device.deviceName} 检查停机记录异常", ex);
|
|
|
return 0; // 出现异常时，不操作
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 安全获取bool值
|
|
|
/// </summary>
|
|
|
/// <param name="value"></param>
|
|
|
/// <returns></returns>
|
|
|
private bool GetBoolValue(object value)
|
|
|
{
|
|
|
if (value == null) return false;
|
|
|
|
|
|
try
|
|
|
{
|
|
|
if (value is bool boolValue)
|
|
|
return boolValue;
|
|
|
|
|
|
if (value is string stringValue)
|
|
|
{
|
|
|
if (bool.TryParse(stringValue, out bool result))
|
|
|
return result;
|
|
|
|
|
|
// 尝试其他常见表示方式
|
|
|
if (stringValue == "1" || stringValue.Equals("true", StringComparison.OrdinalIgnoreCase))
|
|
|
return true;
|
|
|
if (stringValue == "0" || stringValue.Equals("false", StringComparison.OrdinalIgnoreCase))
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 尝试转换
|
|
|
return Convert.ToBoolean(value);
|
|
|
}
|
|
|
catch
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 终止所有采集任务
|
|
|
/// </summary>
|
|
|
public void CancelAllCollectTasks()
|
|
|
{
|
|
|
if (!_cts.IsCancellationRequested)
|
|
|
{
|
|
|
_cts.Cancel();
|
|
|
Console.WriteLine($"[{DateTime.Now}] 已触发采集任务终止");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 计算两个时间之间的持续时间（分钟），四舍五入取整
|
|
|
/// </summary>
|
|
|
/// <param name="startTime">开始时间</param>
|
|
|
/// <param name="endTime">结束时间</param>
|
|
|
/// <returns>持续时间的总分钟数（int类型，四舍五入）</returns>
|
|
|
public int CalculateDurationMinutesRounded(DateTime startTime, DateTime endTime)
|
|
|
{
|
|
|
// 验证参数有效性
|
|
|
if (endTime < startTime)
|
|
|
{
|
|
|
// 这里可以根据需求处理，比如返回0或抛出异常
|
|
|
return 0;
|
|
|
// 或者抛出异常：throw new ArgumentException("结束时间不能早于开始时间");
|
|
|
}
|
|
|
|
|
|
// 计算时间差
|
|
|
TimeSpan duration = endTime - startTime;
|
|
|
|
|
|
// 获取总分钟数（double类型），然后四舍五入转换为int
|
|
|
return (int)Math.Round(duration.TotalMinutes);
|
|
|
}
|
|
|
|
|
|
public void Dispose()
|
|
|
{
|
|
|
throw new NotImplementedException();
|
|
|
}
|
|
|
} |