生产者和消费者实际案例

PLC通信引擎，负责生产者消费者调度

public sealed class PlcCommunicationEngine : IDisposable // PLC通信引擎，负责生产者消费者调度
{ // 类型开始
    private readonly ConcurrentQueue<PlcDataPacket> _dataQueue = new(); // 线程安全队列，缓存采集数据包
    private readonly SemaphoreSlim _dataAvailableSemaphore = new(0); // 数据到达信号量，0表示初始无数据
    private readonly Func<CancellationToken, Task<PlcDataPacket>> _readFunc; // 外部注入的PLC读取函数
    private readonly Action<PlcDataPacket>? _consumerAction; // 外部注入的消费处理动作
    private readonly MachineViewModel? _viewModel; // 可选视图模型，用于同步最新数据

    private readonly object _heartbeatLock = new(); // 心跳状态锁，避免多线程并发读写
    private readonly int _heartbeatDIndex; // 心跳使用的D索引（D0=>0）
    private readonly TimeSpan _heartbeatStaleThreshold; // 心跳超时阈值：超过则认为异常
    private readonly TimeSpan _heartbeatCheckInterval; // 心跳后台监测轮询间隔

    private short? _lastHeartbeatValue; // 上一次观测到的心跳值
    private DateTime? _lastHeartbeatChangeTime; // 心跳最后变化时间（来自packet.Timestamp）
    private bool? _lastHeartbeatHealthy; // 上一次判定的健康状态（用于避免重复事件）

    private CancellationTokenSource? _cts; // 任务取消源
    private Task? _producerTask; // 生产者任务句柄
    private Task? _consumerTask; // 消费者任务句柄
    private Task? _heartbeatMonitorTask; // 心跳后台监测任务句柄
    private bool _disposed; // 资源释放标志位

    public int MaxQueueSize { get; init; } = 100; // 队列最大长度，防止堆积过多
    public TimeSpan ReadInterval { get; init; } = TimeSpan.FromMilliseconds(500); // 生产者读取周期
    public TimeSpan ProcessInterval { get; init; } = TimeSpan.FromMilliseconds(50); // 消费者处理节流周期
    public bool IsRunning { get; private set; } // 引擎运行状态

    public event Action<PlcDataPacket>? PacketProduced; // 生产成功事件
    public event Action<PlcDataPacket>? PacketConsumed; // 消费成功事件
    public event Action<Exception>? ErrorOccurred; // 异常上报事件

    public event Action<HeartbeatStatusSnapshot>? HeartbeatStatusChanged; // 心跳健康状态变化事件

    public readonly struct HeartbeatStatusSnapshot // 心跳状态快照
    {
        public HeartbeatStatusSnapshot(short? value, DateTime? lastChangeTime, bool isHealthy, TimeSpan stale)
        {
            Value = value;
            LastChangeTime = lastChangeTime;
            IsHealthy = isHealthy;
            Stale = stale;
        }

        public short? Value { get; }
        public DateTime? LastChangeTime { get; }
        public bool IsHealthy { get; }
        public TimeSpan Stale { get; }
    }

    public PlcCommunicationEngine( // 构造函数开始
        Func<CancellationToken, Task<PlcDataPacket>> readFunc, // 注入读取委托
        Action<PlcDataPacket>? consumerAction = null, // 注入可选消费委托
        MachineViewModel? viewModel = null, // 注入可选视图模型
        int heartbeatDIndex = 0, // 心跳使用D索引（D0=>0）
        TimeSpan? heartbeatStaleThreshold = null, // 心跳超时阈值：超过则认为异常
        TimeSpan? heartbeatCheckInterval = null) // 心跳后台监测轮询间隔
    { // 构造函数体开始
        _readFunc = readFunc ?? throw new ArgumentNullException(nameof(readFunc)); // 校验并保存读取委托
        _consumerAction = consumerAction; // 保存消费委托
        _viewModel = viewModel; // 保存视图模型

        _heartbeatDIndex = heartbeatDIndex; // 保存心跳D索引
        _heartbeatStaleThreshold = heartbeatStaleThreshold ?? TimeSpan.FromSeconds(10); // 默认10秒超时
        _heartbeatCheckInterval = heartbeatCheckInterval ?? TimeSpan.FromMilliseconds(500); // 默认500ms轮询
    } // 构造函数结束

    public void Start() // 启动引擎
    { // Start方法体开始
        ThrowIfDisposed(); // 已释放则抛异常
        if (IsRunning) return; // 正在运行则直接返回

        _cts = new CancellationTokenSource(); // 创建新的取消源
        IsRunning = true; // 标记为运行中

        _producerTask = Task.Run(() => ProducerLoop(_cts.Token), _cts.Token); // 启动生产者后台任务
        _consumerTask = Task.Run(() => ConsumerLoop(_cts.Token), _cts.Token); // 启动消费者后台任务
        _heartbeatMonitorTask = Task.Run(() => HeartbeatMonitorLoop(_cts.Token), _cts.Token); // 启动心跳后台监测任务
    } // Start方法结束

    public async Task StopAsync() // 异步停止引擎
    { // StopAsync方法体开始
        if (!IsRunning) return; // 未运行则无需停止
        if (_cts is null) return; // 取消源为空则直接返回

        _cts.Cancel(); // 通知所有后台任务取消

        try // 进入等待任务结束阶段
        { // try块开始
            if (_producerTask is not null) // 如果生产者任务存在
            { // if块开始
                await _producerTask.ConfigureAwait(false); // 等待生产者任务退出
            } // if块结束
            if (_consumerTask is not null) // 如果消费者任务存在
            { // if块开始
                await _consumerTask.ConfigureAwait(false); // 等待消费者任务退出
            } // if块结束

            if (_heartbeatMonitorTask is not null) // 如果心跳后台监测任务存在
            { // if块开始
                await _heartbeatMonitorTask.ConfigureAwait(false); // 等待心跳监测任务退出
            } // if块结束
        } // try块结束
        catch (OperationCanceledException) // 捕获取消导致的正常异常
        { // catch块开始
            // normal cancellation flow // 这是正常取消流程，无需额外处理
        } // catch块结束
        finally // 无论如何都执行清理
        { // finally块开始
            IsRunning = false; // 复位运行状态
            _cts.Dispose(); // 释放取消源
            _cts = null; // 清空取消源引用
            _producerTask = null; // 清空生产者任务引用
            _consumerTask = null; // 清空消费者任务引用
            _heartbeatMonitorTask = null; // 清空心跳监测任务引用
        } // finally块结束
    } // StopAsync方法结束

    private async Task ProducerLoop(CancellationToken token) // 生产者循环：读取PLC并入队
    { // ProducerLoop方法体开始
        while (!token.IsCancellationRequested && IsRunning) // 在未取消且运行中时循环
        { // while块开始
            try // 尝试一次采集流程
            { // try块开始
                PlcDataPacket packet = await _readFunc(token).ConfigureAwait(false); // 调用读取委托获取数据包

                if (_dataQueue.Count >= MaxQueueSize) // 如果队列达到上限
                { // if块开始
                    _dataQueue.TryDequeue(out _); // 丢弃最旧一条数据，腾出空间
                } // if块结束

                _dataQueue.Enqueue(packet); // 新数据入队
                _dataAvailableSemaphore.Release(); // 释放信号量通知消费者
                PacketProduced?.Invoke(packet); // 触发生产事件

                await Task.Delay(ReadInterval, token).ConfigureAwait(false); // 按配置间隔采样
            } // try块结束
            catch (OperationCanceledException) // 捕获取消异常
            { // catch块开始
                break; // 收到取消则退出循环
            } // catch块结束
            catch (Exception ex) // 捕获非取消异常
            { // catch块开始
                ErrorOccurred?.Invoke(ex); // 上报异常
                await Task.Delay(2000, token).ConfigureAwait(false); // 异常后降频等待再重试
            } // catch块结束
        } // while块结束
    } // ProducerLoop方法结束

    private async Task ConsumerLoop(CancellationToken token) // 消费者循环：等待信号并处理数据
    { // ConsumerLoop方法体开始
        while (!token.IsCancellationRequested) // 未取消时持续消费
        { // while块开始
            try // 尝试一次消费流程
            { // try块开始
                await _dataAvailableSemaphore.WaitAsync(token).ConfigureAwait(false); // 等待至少一条数据可用

                while (_dataQueue.TryDequeue(out PlcDataPacket? packet)) // 批量把队列里当前数据全部取出
                { // 内层while开始
                    _consumerAction?.Invoke(packet); // 调用外部消费逻辑
                    _viewModel?.Update(packet); // 更新视图模型
                    PacketConsumed?.Invoke(packet); // 触发消费完成事件

                    UpdateHeartbeat(packet); // 更新心跳健康状态（按packet.Timestamp判断是否超时）
                } // 内层while结束

                await Task.Delay(ProcessInterval, token).ConfigureAwait(false); // 按配置做轻量节流
            } // try块结束
            catch (OperationCanceledException) // 捕获取消异常
            { // catch块开始
                break; // 取消时退出循环
            } // catch块结束
            catch (Exception ex) // 捕获处理异常
            { // catch块开始
                ErrorOccurred?.Invoke(ex); // 上报异常，不中断总循环
            } // catch块结束
        } // while块结束
    } // ConsumerLoop方法结束

    public void Dispose() // 释放资源
    { // Dispose方法体开始
        if (_disposed) return; // 避免重复释放
        _disposed = true; // 标记已释放

        StopAsync().GetAwaiter().GetResult(); // 同步等待后台任务停止
        _dataAvailableSemaphore.Dispose(); // 释放信号量资源
    } // Dispose方法结束

    private void ThrowIfDisposed() // 已释放检查辅助方法
    { // ThrowIfDisposed方法体开始
        if (_disposed) // 如果已经释放
        { // if块开始
            throw new ObjectDisposedException(nameof(PlcCommunicationEngine)); // 抛出标准对象释放异常
        } // if块结束
    } // ThrowIfDisposed方法结束

    private void UpdateHeartbeat(PlcDataPacket packet) // 更新心跳：检测D点值变化，并计算是否超时
    { // UpdateHeartbeat方法体开始
        DateTime packetTime = packet.Timestamp; // 当前数据包采样时间戳
        short? current = null; // 当前心跳值（缺失时为null）

        if (packet.DValues.Length > _heartbeatDIndex) // 心跳索引在DValues范围内
        { // if块开始
            current = packet.DValues[_heartbeatDIndex]; // 取心跳点当前值
        } // if块结束

        HeartbeatStatusSnapshot snapshot; // 心跳状态快照
        bool shouldNotify = false; // 是否需要通知外部

        lock (_heartbeatLock) // 锁定，避免和监控任务并发修改
        { // lock开始
            if (_lastHeartbeatValue is null) // 首次初始化
            { // if块开始
                _lastHeartbeatValue = current; // 初始化心跳值
                _lastHeartbeatChangeTime = packetTime; // 初始化最后变化时间
            } // if块结束
            else if (_lastHeartbeatValue.Value != current) // 值发生变化
            { // else-if块开始
                _lastHeartbeatValue = current; // 更新心跳值
                _lastHeartbeatChangeTime = packetTime; // 记录最后变化时间
            } // else-if块结束

            TimeSpan stale = _lastHeartbeatChangeTime is null ? TimeSpan.MaxValue : DateTime.Now - _lastHeartbeatChangeTime.Value; // 心跳超时时间
            bool isHealthy = _lastHeartbeatChangeTime is not null && stale <= _heartbeatStaleThreshold; // 当前健康判定

            snapshot = new HeartbeatStatusSnapshot(_lastHeartbeatValue, _lastHeartbeatChangeTime, isHealthy, stale); // 生成快照

            if (_lastHeartbeatHealthy is null || _lastHeartbeatHealthy.Value != isHealthy) // 状态发生变化才通知
            { // if块开始
                _lastHeartbeatHealthy = isHealthy; // 更新最近一次健康状态
                shouldNotify = true; // 标记需要通知
            } // if块结束
        } // lock结束

        if (shouldNotify) // 只有确实发生变化才触发事件
        { // if块开始
            HeartbeatStatusChanged?.Invoke(snapshot); // 通知外部心跳健康状态变化
        } // if块结束
    } // UpdateHeartbeat方法结束

    private async Task HeartbeatMonitorLoop(CancellationToken token) // 心跳后台监控：即使心跳值不再变化也能超时告警
    { // HeartbeatMonitorLoop方法体开始
        while (!token.IsCancellationRequested) // 循环直到取消
        { // while块开始
            try // try块开始
            { // try块内容
                HeartbeatStatusSnapshot? snapshotToSend = null; // 需要发送时才赋值

                lock (_heartbeatLock) // 锁定读取状态
                { // lock开始
                    if (_lastHeartbeatChangeTime is not null) // 已初始化则可计算
                    { // if块开始
                        TimeSpan stale = DateTime.Now - _lastHeartbeatChangeTime.Value; // 计算当前失效时间
                        bool isHealthy = stale <= _heartbeatStaleThreshold; // 判定是否健康

                        if (_lastHeartbeatHealthy is null || _lastHeartbeatHealthy.Value != isHealthy) // 状态变化才通知
                        { // if块开始
                            _lastHeartbeatHealthy = isHealthy; // 更新缓存
                            snapshotToSend = new HeartbeatStatusSnapshot(_lastHeartbeatValue, _lastHeartbeatChangeTime, isHealthy, stale); // 生成快照
                        } // if块结束
                    } // if块结束
                } // lock结束

                if (snapshotToSend is not null) // 有变化
                { // if块开始
                    HeartbeatStatusChanged?.Invoke(snapshotToSend.Value); // 触发事件
                } // if块结束
            } // try块结束
            catch // 忽略心跳监控异常，避免监控任务中断
            { // catch块开始
            } // catch块结束

            await Task.Delay(_heartbeatCheckInterval, token).ConfigureAwait(false); // 按轮询间隔等待
        } // while块结束
    } // HeartbeatMonitorLoop方法结束
} // 类型结束

PLC数据结构

public sealed class PlcDataPacket
{
    public DateTime Timestamp { get; init; } = DateTime.Now;
    public short[] DValues { get; init; } = Array.Empty<short>();
    public bool[] XValues { get; init; } = Array.Empty<bool>();
}

UI层数据-----观察者

public sealed class MachineViewModel
{
    public PlcDataPacket? LastPacket { get; private set; }

    public void Update(PlcDataPacket packet)
    {
        LastPacket = packet;
    }
}