[제140편 기념] 스마트 교구 센서와 군 통신장비를 수호하는 무결점 하드웨어 제어: ZeliDesk.Services SerialPortManager의 RS232 시리얼 COM 인터롭, 비동기 스레드 예외 방어 및 ConcurrentDictionary 다중 포트 아키텍처

port.ErrorReceived += (s, e) =>
{
    // [보안 아키텍처 핵심 주석]
    // 이벤트는 SerialPort 내부 백그라운드 스레드에서 발생한다. 
    // 구독자가 예외를 던지면 그대로 스레드 밖으로 전파되어 
    // 프로세스가 죽으므로 완전 격리 try-catch로 감싼다.
    try 
    { 
        ErrorOccurred?.Invoke(portName, $"포트 오류: {e.EventType}"); 
    }
    catch 
    { 
        // 외부 구독자의 핸들러 예외가 OS 스레드 풀을 파괴하지 못하도록 격리
    }
};

port.DataReceived += (s, e) =>
{
    try
    {
        var sp = (SerialPort)s;
        string data = sp.ReadExisting();
        if (!string.IsNullOrEmpty(data))
        {
            DataReceived?.Invoke(portName, data);
        }
    }
    catch (Exception ex)
    {
        try { ErrorOccurred?.Invoke(portName, $"읽기 오류: {ex.Message}"); }
        catch { }
    }
};

public bool Close(string portName)
{
    try
    {
        // 원자적 제거 후 열림 상태 확인 및 자원 완전 소거
        if (_openPorts.TryRemove(portName, out var port))
        {
            if (port.IsOpen) port.Close();
            port.Dispose();
            return true;
        }
        return false;
    }
    catch (Exception ex)
    {
        ErrorOccurred?.Invoke(portName, $"닫기 실패: {ex.Message}");
        return false;
    }
}

using System;
using System.Collections.Concurrent;
using System.IO.Ports;
using System.Text;

namespace ZeliDesk.Services
{
    /// <summary>
    /// RS232 시리얼 포트 관리자.
    /// WebBridge를 통해 웹 브라우저 및 온디바이스 AI에서 물리 시리얼 포트를 무결 제어합니다.
    /// </summary>
    public class SerialPortManager : IDisposable
    {
        // 열려 있는 포트들을 원자적으로 관리 (포트 이름 → SerialPort 인스턴스)
        private readonly ConcurrentDictionary<string, SerialPort> _openPorts = new();

        // 비동기 이벤트 수신 시 안전하게 디스패치되는 이벤트 델리게이트
        public event Action<string, string> DataReceived;   // (portName, data)
        public event Action<string, string> ErrorOccurred;  // (portName, errorMessage)

        /// <summary>
        /// 시스템에서 물리적/가상으로 사용 가능한 COM 포트 목록을 즉시 열거합니다.
        /// </summary>
        public string[] GetAvailablePorts()
        {
            return SerialPort.GetPortNames();
        }

        /// <summary>
        /// 지정된 통신 규격(BaudRate, Parity, DataBits, StopBits)으로 시리얼 포트를 오픈합니다.
        /// </summary>
        public bool Open(string portName, int baudRate = 9600, string parity = "None",
                         int dataBits = 8, string stopBits = "One")
        {
            try
            {
                if (_openPorts.ContainsKey(portName))
                {
                    ErrorOccurred?.Invoke(portName, $"포트 '{portName}'가 이미 열려 있습니다.");
                    return false;
                }

                var port = new SerialPort
                {
                    PortName = portName,
                    BaudRate = baudRate,
                    Parity = ParseParity(parity),
                    DataBits = dataBits,
                    StopBits = ParseStopBits(stopBits),
                    Encoding = Encoding.UTF8,
                    ReadTimeout = 3000,
                    WriteTimeout = 3000
                };

                // 비동기 수신 이벤트 핸들러 (2중 예외 샌드박싱)
                port.DataReceived += (s, e) =>
                {
                    try
                    {
                        var sp = (SerialPort)s;
                        string data = sp.ReadExisting();
                        if (!string.IsNullOrEmpty(data))
                        {
                            DataReceived?.Invoke(portName, data);
                        }
                    }
                    catch (Exception ex)
                    {
                        try { ErrorOccurred?.Invoke(portName, $"읽기 오류: {ex.Message}"); }
                        catch { }
                    }
                };

                // 백그라운드 스레드 에러 핸들러 (프로세스 크래시 완전 방어)
                port.ErrorReceived += (s, e) =>
                {
                    try { ErrorOccurred?.Invoke(portName, $"포트 오류: {e.EventType}"); }
                    catch { }
                };

                port.Open();
                _openPorts[portName] = port;
                return true;
            }
            catch (Exception ex)
            {
                ErrorOccurred?.Invoke(portName, $"열기 실패: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 지정된 포트로 데이터를 안전하게 송신합니다.
        /// </summary>
        public bool Write(string portName, string data)
        {
            try
            {
                if (!_openPorts.TryGetValue(portName, out var port) || !port.IsOpen)
                {
                    ErrorOccurred?.Invoke(portName, $"포트 '{portName}'가 열려 있지 않습니다.");
                    return false;
                }

                port.Write(data);
                return true;
            }
            catch (Exception ex)
            {
                ErrorOccurred?.Invoke(portName, $"쓰기 실패: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 포트를 안전하게 닫고 자원을 원자적으로 해제합니다.
        /// </summary>
        public bool Close(string portName)
        {
            try
            {
                if (_openPorts.TryRemove(portName, out var port))
                {
                    if (port.IsOpen) port.Close();
                    port.Dispose();
                    return true;
                }
                return false;
            }
            catch (Exception ex)
            {
                ErrorOccurred?.Invoke(portName, $"닫기 실패: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// 특정 포트의 열림 상태를 안전하게 조회합니다.
        /// </summary>
        public bool IsOpen(string portName)
        {
            return _openPorts.TryGetValue(portName, out var port) && port.IsOpen;
        }

        /// <summary>
        /// 솔루션 종료 시 모든 열린 포트를 일괄 종료하고 메모리를 클린업합니다.
        /// </summary>
        public void Dispose()
        {
            foreach (var kvp in _openPorts)
            {
                try
                {
                    if (kvp.Value.IsOpen) kvp.Value.Close();
                    kvp.Value.Dispose();
                }
                catch { }
            }
            _openPorts.Clear();
        }

        // ═══ 선언적 스위치 표현식 유틸리티 ═══
        private static Parity ParseParity(string value) => value?.ToLower() switch
        {
            "odd" => Parity.Odd,
            "even" => Parity.Even,
            "mark" => Parity.Mark,
            "space" => Parity.Space,
            _ => Parity.None
        };

        private static StopBits ParseStopBits(string value) => value?.ToLower() switch
        {
            "two" or "2" => StopBits.Two,
            "onepointfive" or "1.5" => StopBits.OnePointFive,
            "none" or "0" => StopBits.None,
            _ => StopBits.One
        };
    }
}