xiaowei/DMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初步完成数据处理链条

Browse Source
This commit is contained in:
David P.G
2025-09-04 13:40:07 +08:00
parent bdae3355aa
commit bc8bc58d9b
18 changed files with 175 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
DMS.WPF/Services/DataProcessingService.cs
View File

@@ -1,99 +0,0 @@
using System.Threading.Channels;
using DMS.Core.Helper;
using DMS.Core.Models;
using DMS.WPF.Interfaces;
using Microsoft.Extensions.Hosting;
namespace DMS.Services;
/// <summary>
/// 核心数据处理服务，作为后台服务运行。
/// 它维护一个无界通道（Channel）作为处理队列，并按顺序执行已注册的数据处理器。
/// </summary>
public class DataProcessingService : BackgroundService, IDataProcessingService
{
// 使用 Channel 作为高性能的生产者/消费者队列
private readonly Channel<VariableContext> _queue;
// 存储数据处理器的链表
private readonly List<IVariableProcessor> _processors;
/// <summary>
/// 构造函数，注入日志记录器。
/// </summary>
/// <param name="logger">日志记录器实例。</param>
public DataProcessingService()
{
// 创建一个无边界的 Channel，允许生产者快速写入而不会被阻塞。
_queue = Channel.CreateUnbounded<VariableContext>();
_processors = new List<IVariableProcessor>();
}
/// <summary>
/// 向处理链中添加一个数据处理器。
/// 处理器将按照添加的顺序执行。
/// </summary>
/// <param name="processor">要添加的数据处理器实例。</param>
public void AddProcessor(IVariableProcessor processor)
{
_processors.Add(processor);
}
/// <summary>
/// 将一个变量数据项异步推入处理队列。
/// </summary>
/// <param name="data">要入队的变量数据。</param>
public async ValueTask EnqueueAsync(Variable data)
{
if (data == null)
{
return;
}
var context = new VariableContext(data);
// 将数据项写入 Channel，供后台服务处理。
await _queue.Writer.WriteAsync(context);
}
/// <summary>
/// 后台服务的核心执行逻辑。
/// 此方法会持续运行，从队列中读取数据并交由处理器链处理。
/// </summary>
/// <param name="stoppingToken">用于通知服务停止的取消令牌。</param>
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
NlogHelper.Info("数据处理服务已启动。");
// 当服务未被请求停止时，持续循环
while (!stoppingToken.IsCancellationRequested)
{
try
{
// 从队列中异步读取一个数据项，如果队列为空，则等待。
var context = await _queue.Reader.ReadAsync(stoppingToken);
// 依次调用处理链中的每一个处理器
foreach (var processor in _processors)
{
if (context.IsHandled)
{
// NlogHelper.Info($"{context.Data.Name}的数据处理已短路，跳过后续处理器。");
break; // 短路，跳过后续处理器
}
await processor.ProcessAsync(context);
}
}
catch (OperationCanceledException)
{
// 当 stoppingToken 被触发时，ReadAsync 会抛出此异常，属正常停止流程，无需处理。
}
catch (Exception ex)
{
NlogHelper.Error($"处理变量数据时发生错误:{ex.Message}", ex);
}
}
NlogHelper.Info("数据处理服务已停止。");
}
}

36
DMS.WPF/Services/Processors/CheckValueChangedProcessor.cs
View File

@@ -1,36 +0,0 @@
using DMS.Core.Helper;
using DMS.Core.Models;
using DMS.Helper;
using DMS.WPF.Interfaces;
using DMS.WPF.Services;
namespace DMS.Services.Processors;
public class CheckValueChangedProcessor : IVariableProcessor
{
private readonly DataServices _dataServices;
public CheckValueChangedProcessor(DataServices dataServices)
{
_dataServices = dataServices;
}
public Task ProcessAsync(VariableContext context)
{
Variable newVariable = context.Data;
// if (!_dataServices.AllVariables.TryGetValue(newVariable.Id, out Variable oldVariable))
// {
// NlogHelper.Warn($"检查变量值是否改变时在_dataServices.AllVariables中找不到Id:{newVariable.Id},Name:{newVariable.Name}的变量。");
// context.IsHandled = true;
// return Task.CompletedTask;
// }
// if (newVariable.DataValue == oldVariable.DataValue)
// {
// // 值没有变化，直接完成
// context.IsHandled = true;
// }
//
// 在这里处理 context.Data
return Task.CompletedTask;
}
}

87
DMS.WPF/Services/Processors/HistoryProcessor.cs
View File

@@ -1,87 +0,0 @@
using DMS.Core.Helper;
using DMS.Core.Models;
using DMS.Services;
using DMS.WPF.Interfaces;
using Microsoft.Extensions.Logging;
namespace DMS.WPF.Services.Processors;
public class HistoryProcessor : IVariableProcessor, IDisposable
{
private const int BATCH_SIZE = 50; // 批量写入的阈值
private const int TIMER_INTERVAL_MS = 30 * 1000; // 30秒
// private readonly ConcurrentQueue<DbVariableHistory> _queue = new();
private readonly Timer _timer;
public HistoryProcessor()
{
_timer = new Timer(async _ => await FlushQueueToDatabase(), null, Timeout.Infinite, Timeout.Infinite);
_timer.Change(TIMER_INTERVAL_MS, TIMER_INTERVAL_MS); // 启动定时器
}
public async Task ProcessAsync(VariableContext context)
{
// 只有当数据发生变化时才记录历史
// if (!context.Data.IsSave) // 如果数据已经被其他处理器处理过或者不需要保存，则跳过
// {
// return;
// }
//
// // 将 Variable 转换为 DbVariableHistory
// var historyData = new DbVariableHistory
// {
// Name = context.Data.Name,
// NodeId = context.Data.NodeId,
// DataValue = context.Data.DataValue,
// VariableId = context.Data.Id,
// Timestamp = DateTime.Now // 记录当前时间
// };
//
// _queue.Enqueue(historyData);
//
// if (_queue.Count >= BATCH_SIZE)
// {
// await FlushQueueToDatabase();
// }
}
private async Task FlushQueueToDatabase()
{
// 停止定时器，防止在写入过程中再次触发
// _timer.Change(Timeout.Infinite, Timeout.Infinite);
//
// var itemsToProcess = new List<DbVariableHistory>();
// while (_queue.TryDequeue(out var item))
// {
// itemsToProcess.Add(item);
// }
//
// if (itemsToProcess.Any())
// {
// try
// {
// using var db = DbContext.GetInstance();
// await db.Insertable(itemsToProcess).ExecuteCommandAsync();
// NlogHelper.Info($"成功批量插入 {itemsToProcess.Count} 条历史变量数据。");
// }
// catch (Exception ex)
// {
// NlogHelper.Error( $"批量插入历史变量数据时发生错误: {ex.Message}",ex);
// // 错误处理：可以将未成功插入的数据重新放回队列，或者记录到日志中以便后续处理
// // 为了简单起见，这里不重新入队，避免无限循环
// }
// }
// 重新启动定时器
_timer.Change(TIMER_INTERVAL_MS, TIMER_INTERVAL_MS);
}
public void Dispose()
{
_timer?.Dispose();
// 在 Dispose 时，尝试将剩余数据写入数据库
FlushQueueToDatabase().Wait();
}
}

24
DMS.WPF/Services/Processors/LoggingProcessor.cs
View File

@@ -1,24 +0,0 @@
using System.Threading.Tasks;
using DMS.Core.Models;
using Microsoft.Extensions.Logging;
using DMS.Helper;
using DMS.WPF.Interfaces;
namespace DMS.Services.Processors;
/// <summary>
/// 一个简单的数据处理器实现，用于演示。
/// 其主要功能是记录接收到的变量数据的名称和值。
/// </summary>
public class LoggingProcessor : IVariableProcessor
{
public LoggingProcessor()
{
}
public Task ProcessAsync(VariableContext context)
{
// NlogHelper.Info($"处理数据: {context.Data.Name}, 值: {context.Data.DataValue}");
return Task.CompletedTask;
}
}

40
DMS.WPF/Services/Processors/MqttPublishProcessor.cs
View File

@@ -1,40 +0,0 @@
using System.Threading.Tasks;
using DMS.Core.Models;
using DMS.WPF.Interfaces;
namespace DMS.Services.Processors
{
/// <summary>
/// 负责将变量数据发布到MQTT的处理器。
/// </summary>
public class MqttPublishProcessor : IVariableProcessor
{
// private readonly MqttBackgroundService _mqttBackgroundService;
//
// public MqttPublishProcessor(MqttBackgroundService mqttBackgroundService)
// {
// _mqttBackgroundService = mqttBackgroundService;
// }
/// <summary>
/// 处理单个变量上下文，如果有关联的MQTT配置，则将其推送到发送队列。
/// </summary>
/// <param name="context">包含变量及其元数据的上下文对象。</param>
public async Task ProcessAsync(VariableContext context)
{
// var variable = context.Data;
// if (variable?.VariableMqtts == null || variable.VariableMqtts.Count == 0)
// {
// return; // 没有关联的MQTT配置，直接返回
// }
//
// // 遍历所有关联的MQTT配置，并将其推入发送队列
// foreach (var variableMqtt in variable.VariableMqtts)
// {
// // 确保VariableMqtt对象中包含了最新的Variable数据
// variableMqtt.Variable = variable;
// await _mqttBackgroundService.SendVariableAsync(variableMqtt);
// }
}
}
}

40
DMS.WPF/Services/Processors/UpdateDbVariableProcessor.cs
View File

@@ -1,40 +0,0 @@
using System.Threading.Tasks;
using DMS.Core.Helper;
using DMS.Core.Models;
using DMS.Helper;
using DMS.WPF.Interfaces;
using DMS.WPF.Services;
namespace DMS.Services.Processors
{
public class UpdateDbVariableProcessor : IVariableProcessor
{
private readonly DataServices _dataServices;
public UpdateDbVariableProcessor(DataServices dataServices)
{
_dataServices = dataServices;
}
public async Task ProcessAsync(VariableContext context)
{
try
{
// 假设 DataServices 有一个方法来更新 Variable
// await _dataServices.UpdateVariableAsync(context.Data);
// NlogHelper.Info($"数据库变量 {context.Data.Name} 更新成功，值为: {context.Data.DataValue}");
// if (!_dataServices.AllVariables.TryGetValue(context.Data.Id, out Variable oldVariable))
// {
// NlogHelper.Warn($"数据库更新完成修改变量值是否改变时在_dataServices.AllVariables中找不到Id:{context.Data.Id},Name:{context.Data.Name}的变量。");
// context.IsHandled = true;
// }
// oldVariable.DataValue = context.Data.DataValue;
}
catch (Exception ex)
{
NlogHelper.Error($"更新数据库变量 {context.Data.Name} 失败: {ex.Message}", ex);
}
}
}
}