Ayay/SHH.CameraService/Core/CmdClients/CommandClientWorker.cs

//using System.Text;
//using MessagePack;
//using Microsoft.Extensions.Hosting;
//using NetMQ;
//using NetMQ.Monitoring; // ★ 1. 必须引用 Monitoring 命名空间
//using NetMQ.Sockets;
//using SHH.CameraSdk;
//using SHH.Contracts;

//namespace SHH.CameraService;

//public class CommandClientWorker : BackgroundService
//{
//    private readonly ServiceConfig _config;
//    private readonly CommandDispatcher _dispatcher;
//    private readonly InterceptorPipeline _pipeline;

//    // 管理多个 Socket
//    private readonly List<DealerSocket> _sockets = new();

//    // ★ 2. 新增：保存 Monitor 列表，防止被 GC 回收
//    private readonly List<NetMQMonitor> _monitors = new();

//    private NetMQPoller? _poller;

//    public CommandClientWorker(
//        ServiceConfig config,
//        CommandDispatcher dispatcher,
//        InterceptorPipeline pipeline)
//    {
//        _config = config;
//        _dispatcher = dispatcher;
//        _pipeline = pipeline;
//    }

//    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
//    {
//        await Task.Yield();

//        if (!_config.ShouldConnect || _config.CommandEndpoints.Count == 0) return;

//        _poller = new NetMQPoller();

//        // -------------------------------------------------------------
//        // 核心修改区：建立连接并挂载监控器
//        // -------------------------------------------------------------
//        foreach (var ep in _config.CommandEndpoints)
//        {
//            try
//            {
//                var socket = new DealerSocket();
//                socket.Options.Identity = Encoding.UTF8.GetBytes(_config.AppId);

//                var monitorUrl = $"inproc://monitor_{Guid.NewGuid():N}";
//                var monitor = new NetMQMonitor(socket, monitorUrl, SocketEvents.Connected);

//                monitor.Connected += async (s, args) =>
//                {
//                    Console.WriteLine($"[指令] 网络连接建立: {ep.Uri} -> 正在补发注册包...");
//                    await SendRegisterAsync(socket);
//                };

//                // ★★★ 修正点：使用 AttachToPoller 代替 Add ★★★
//                // 错误写法: _poller.Add(monitor); 
//                monitor.AttachToPoller(_poller);

//                // 依然需要保存引用，防止被 GC 回收
//                _monitors.Add(monitor);

//                socket.Connect(ep.Uri);
//                socket.ReceiveReady += OnSocketReceiveReady;

//                _sockets.Add(socket);
//                _poller.Add(socket);

//                Console.WriteLine($"[指令] 通道初始化完成: {ep.Uri} (带自动重连监控)");
//            }
//            catch (Exception ex)
//            {
//                Console.WriteLine($"[指令] 连接初始化异常: {ex.Message}");
//            }
//        }

//        if (_sockets.Count == 0) return;

//        // =================================================================
//        // 6. 绑定 ACK 逻辑 (保持不变)
//        // =================================================================
//        _dispatcher.OnResponseReady += async (result) =>
//        {
//            try
//            {
//                byte[] resultBytes = MessagePackSerializer.Serialize(result);
//                var ctx = await _pipeline.ExecuteSendAsync(ProtocolHeaders.CommandResult, resultBytes);

//                if (ctx != null)
//                {
//                    foreach (var socket in _sockets)
//                    {
//                        socket.SendMoreFrame(ctx.Protocol).SendFrame(ctx.Data);
//                    }
//                    Console.WriteLine($"[指令] ACK 已广播 (ID: {result.RequestId})");
//                }
//            }
//            catch (Exception ex)
//            {
//                Console.WriteLine($"[ACK] 发送失败: {ex.Message}");
//            }
//        };

//        // =================================================================
//        // 7. 启动 Poller
//        // =================================================================
//        // 注意：我们不需要手动发第一次注册包了，
//        // 因为 Poller 启动后，底层 TCP 会建立连接，从而触发 monitor.Connected 事件，
//        // 事件里会自动发送注册包。这就是“自动档”的好处。
//        _poller.RunAsync();

//        // 阻塞直到取消
//        while (!stoppingToken.IsCancellationRequested)
//        {
//            await Task.Delay(1000, stoppingToken);
//        }

//        // 清理
//        _poller.Stop();
//        _poller.Dispose();
//        foreach (var m in _monitors) m.Dispose(); // 释放监控器
//        foreach (var s in _sockets) s.Dispose();
//    }

//    // =================================================================
//    // ★ 8. 抽离出的注册包发送逻辑 (供 Monitor 调用)
//    // =================================================================
//    private async Task SendRegisterAsync(DealerSocket targetSocket)
//    {
//        try
//        {
//            var registerPayload = new RegisterPayload
//            {
//                Protocol = ProtocolHeaders.ServerRegister,
//                InstanceId = _config.AppId,
//                ProcessId = Environment.ProcessId,
//                Version = "1.0.0",
//                ServerIp = "127.0.0.1", // 建议优化：获取本机真实IP
//                WebApiPort = _config.BasePort,
//                StartTime = DateTime.Now
//            };

//            byte[] regData = MessagePackSerializer.Serialize(registerPayload);

//            // 执行拦截器
//            var ctx = await _pipeline.ExecuteSendAsync(ProtocolHeaders.ServerRegister, regData);

//            if (ctx != null)
//            {
//                // 直接向触发事件的那个 Socket 发送
//                // DealerSocket 允许在连接未完全就绪时 Send，它会缓存直到网络通畅
//                targetSocket.SendMoreFrame(ctx.Protocol).SendFrame(ctx.Data);
//                // Console.WriteLine($"[指令] 身份注册包已推入队列: {targetSocket.Options.Identity}");
//            }
//        }
//        catch (Exception ex)
//        {
//            Console.WriteLine($"[指令] 注册包发送失败: {ex.Message}");
//        }
//    }

//    private async void OnSocketReceiveReady(object? sender, NetMQSocketEventArgs e)
//    {
//        NetMQMessage incomingMsg = new NetMQMessage();
//        if (e.Socket.TryReceiveMultipartMessage(ref incomingMsg))
//        {
//            if (incomingMsg.FrameCount >= 2)
//            {
//                try
//                {
//                    string rawProtocol = incomingMsg[0].ConvertToString();
//                    byte[] rawData = incomingMsg[1].ToByteArray();

//                    var ctx = await _pipeline.ExecuteReceiveAsync(rawProtocol, rawData);
//                    if (ctx != null)
//                    {
//                        await _dispatcher.DispatchAsync(ctx.Protocol, ctx.Data);
//                    }
//                }
//                catch (Exception ex)
//                {
//                    Console.WriteLine($"[指令] 处理异常: {ex.Message}");
//                }
//            }
//        }
//    }
//}