/// <summary>
/// 平臺(tái)檢測服務(wù)類
/// 用于識別當(dāng)前運(yùn)行的操作系統(tǒng)平臺(tái)
/// </summary>
public static class PlatformDetector
{
    /// <summary>
    /// 檢測當(dāng)前是否為Windows平臺(tái)
    /// </summary>
    /// <returns>如果是Windows平臺(tái)返回true，否則返回false</returns>
    public static bool IsWindows()
    {
        return RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
    }

    /// <summary>
    /// 檢測當(dāng)前是否為Linux平臺(tái)
    /// </summary>
    /// <returns>如果是Linux平臺(tái)返回true，否則返回false</returns>
    public static bool IsLinux()
    {
        return RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
    }

    /// <summary>
    /// 檢測當(dāng)前是否為macOS平臺(tái)
    /// </summary>
    /// <returns>如果是macOS平臺(tái)返回true，否則返回false</returns>
    public static bool IsMacOS()
    {
        return RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
    }

    /// <summary>
    /// 獲取當(dāng)前平臺(tái)的串口路徑前綴
    /// </summary>
    /// <returns>串口路徑前綴字符串</returns>
    public static string GetSerialPortPrefix()
    {
        if (IsWindows())
            return "COM";
        else if (IsLinux())
            return "/dev/ttyUSB";
        else if (IsMacOS())
            return "/dev/cu.";
        else
            throw new PlatformNotSupportedException("不支持的操作系統(tǒng)平臺(tái)");
    }
}

using System;
using System.IO.Ports;
using System.Threading.Tasks;
using System.Windows.Forms;

/// <summary>
/// Windows平臺(tái)串口通訊實(shí)現(xiàn)類
/// 基于System.IO.Ports.SerialPort的Windows原生實(shí)現(xiàn)
/// </summary>
public class WindowsSerialPortService : ISerialPortService
{
    private SerialPort _serialPort;
    private bool _isOpen;

    /// <summary>
    /// 數(shù)據(jù)接收事件
    /// 當(dāng)有數(shù)據(jù)到達(dá)時(shí)觸發(fā)此事件
    /// </summary>
    public event Action<byte[]> DataReceived;

    /// <summary>
    /// 獲取串口是否已打開
    /// </summary>
    public bool IsOpen => _isOpen && _serialPort?.IsOpen == true;

    /// <summary>
    /// 構(gòu)造函數(shù)，初始化Windows串口服務(wù)
    /// </summary>
    public WindowsSerialPortService()
    {
        _serialPort = new SerialPort();
        _isOpen = false;
    }

    /// <summary>
    /// 打開指定的串口
    /// </summary>
    /// <param name="portName">COM端口名稱，例如：COM1, COM2</param>
    /// <param name="baudRate">波特率，默認(rèn)9600</param>
    /// <param name="dataBits">數(shù)據(jù)位，默認(rèn)8位</param>
    /// <param name="parity">校驗(yàn)位，默認(rèn)無校驗(yàn)</param>
    /// <param name="stopBits">停止位，默認(rèn)1位</param>
    /// <returns>成功打開返回true，否則返回false</returns>
    public bool Open(string portName, int baudRate = 9600, int dataBits = 8, 
                    Parity parity = Parity.None, StopBits stopBits = StopBits.One)
    {
        try
        {
            if (_isOpen)
            {
                Close(); // 如果已經(jīng)打開，先關(guān)閉
            }

            // 配置串口參數(shù)
            _serialPort.PortName = portName;
            _serialPort.BaudRate = baudRate;
            _serialPort.DataBits = dataBits;
            _serialPort.Parity = parity;
            _serialPort.StopBits = stopBits;
            
            // 設(shè)置超時(shí)時(shí)間
            _serialPort.ReadTimeout = 1000;
            _serialPort.WriteTimeout = 1000;
            
            // 啟用數(shù)據(jù)到達(dá)事件
            _serialPort.DataReceived += SerialPort_DataReceived;

            // 打開串口
            _serialPort.Open();
            _isOpen = true;

            return true;
        }
        catch (Exception ex)
        {
            // 記錄錯(cuò)誤日志
            MessageBox.Show($"打開串口失敗: {ex.Message}", "錯(cuò)誤", 
                          MessageBoxButtons.OK, MessageBoxIcon.Error);
            return false;
        }
    }

    /// <summary>
    /// 關(guān)閉串口連接
    /// </summary>
    public void Close()
    {
        try
        {
            if (_serialPort?.IsOpen == true)
            {
                _serialPort.DataReceived -= SerialPort_DataReceived;
                _serialPort.Close();
            }
            _isOpen = false;
        }
        catch (Exception ex)
        {
            // 記錄關(guān)閉串口時(shí)的錯(cuò)誤
            Console.WriteLine($"關(guān)閉串口時(shí)發(fā)生錯(cuò)誤: {ex.Message}");
        }
    }

    /// <summary>
    /// 向串口寫入數(shù)據(jù)
    /// </summary>
    /// <param name="data">要發(fā)送的字節(jié)數(shù)組</param>
    /// <returns>實(shí)際發(fā)送的字節(jié)數(shù)</returns>
    public int Write(byte[] data)
    {
        try
        {
            if (!IsOpen)
            {
                throw new InvalidOperationException("串口未打開");
            }

            _serialPort.Write(data, 0, data.Length);
            return data.Length;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"寫入數(shù)據(jù)失敗: {ex.Message}");
            return 0;
        }
    }

    /// <summary>
    /// 從串口讀取數(shù)據(jù)
    /// </summary>
    /// <param name="buffer">接收數(shù)據(jù)的緩沖區(qū)</param>
    /// <returns>實(shí)際讀取的字節(jié)數(shù)</returns>
    public int Read(byte[] buffer)
    {
        try
        {
            if (!IsOpen)
            {
                return 0;
            }

            return _serialPort.Read(buffer, 0, buffer.Length);
        }
        catch (TimeoutException)
        {
            // 讀取超時(shí)是正?，F(xiàn)象，返回0
            return 0;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"讀取數(shù)據(jù)失敗: {ex.Message}");
            return 0;
        }
    }

    /// <summary>
    /// 獲取系統(tǒng)中可用的串口列表
    /// </summary>
    /// <returns>可用串口名稱數(shù)組</returns>
    public string[] GetAvailablePorts()
    {
        try
        {
            return SerialPort.GetPortNames();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"獲取串口列表失敗: {ex.Message}");
            return new string[0];
        }
    }

    /// <summary>
    /// 串口數(shù)據(jù)接收事件處理器
    /// </summary>
    private void SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)
    {
        try
        {
            SerialPort sp = sender as SerialPort;
            int bytesToRead = sp.BytesToRead;
            
            if (bytesToRead > 0)
            {
                byte[] buffer = new byte[bytesToRead];
                int bytesRead = sp.Read(buffer, 0, bytesToRead);
                
                if (bytesRead > 0)
                {
                    // 調(diào)整數(shù)組大小以匹配實(shí)際讀取的數(shù)據(jù)
                    Array.Resize(ref buffer, bytesRead);
                    DataReceived?.Invoke(buffer);
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"接收數(shù)據(jù)時(shí)發(fā)生錯(cuò)誤: {ex.Message}");
        }
    }

    /// <summary>
    /// 釋放資源
    /// </summary>
    public void Dispose()
    {
        Close();
        _serialPort?.Dispose();
    }
}

using System.Management;
using System.Collections.Generic;

/// <summary>
/// Windows設(shè)備信息查詢類
/// 用于獲取詳細(xì)的串口設(shè)備信息
/// </summary>
public class WindowsDeviceManager
{
    /// <summary>
    /// 串口設(shè)備信息結(jié)構(gòu)
    /// </summary>
    public class SerialPortInfo
    {
        public string PortName { get; set; }
        public string Description { get; set; }
        public string Manufacturer { get; set; }
        public string DeviceID { get; set; }
        public bool IsPresent { get; set; }
    }

    /// <summary>
    /// 通過WMI查詢獲取詳細(xì)的串口設(shè)備信息
    /// </summary>
    /// <returns>串口設(shè)備信息列表</returns>
    public static List<SerialPortInfo> GetDetailedPortInfo()
    {
        List<SerialPortInfo> portInfoList = new List<SerialPortInfo>();

        try
        {
            // 使用WMI查詢串口設(shè)備
            ManagementObjectSearcher searcher = new ManagementObjectSearcher(
                "SELECT * FROM Win32_PnPEntity WHERE ClassGuid=\"{4d36e978-e325-11ce-bfc1-08002be10318}\"");

            foreach (ManagementObject obj in searcher.Get())
            {
                string name = obj["Name"]?.ToString();
                if (!string.IsNullOrEmpty(name) && name.Contains("COM"))
                {
                    // 提取COM端口號
                    int startIndex = name.IndexOf("COM");
                    int endIndex = name.IndexOf(")", startIndex);
                    string portName = endIndex > startIndex ? 
                        name.Substring(startIndex, endIndex - startIndex) : 
                        name.Substring(startIndex);

                    SerialPortInfo portInfo = new SerialPortInfo
                    {
                        PortName = portName,
                        Description = name,
                        Manufacturer = obj["Manufacturer"]?.ToString(),
                        DeviceID = obj["DeviceID"]?.ToString(),
                        IsPresent = obj["Present"]?.ToString().ToLower() == "true"
                    };

                    portInfoList.Add(portInfo);
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"WMI查詢失敗: {ex.Message}");
        }

        return portInfoList;
    }

    /// <summary>
    /// 檢查指定COM端口是否存在且可用
    /// </summary>
    /// <param name="portName">COM端口名稱</param>
    /// <returns>如果端口存在且可用返回true</returns>
    public static bool IsPortAvailable(string portName)
    {
        try
        {
            using (SerialPort testPort = new SerialPort(portName))
            {
                testPort.Open();
                testPort.Close();
                return true;
            }
        }
        catch
        {
            return false;
        }
    }
}

# 查看當(dāng)前用戶所屬的組
groups $USER

# 將用戶添加到dialout組以獲取串口訪問權(quán)限
sudo usermod -a -G dialout $USER

# 臨時(shí)修改串口設(shè)備權(quán)限（重啟后失效）
sudo chmod 666 /dev/ttyUSB0

using System;
using System.IO;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;

/// <summary>
/// Linux平臺(tái)串口通訊實(shí)現(xiàn)類
/// 使用底層文件操作方式實(shí)現(xiàn)串口通訊
/// </summary>
public class LinuxSerialPortService : ISerialPortService
{
    // P/Invoke 聲明Linux系統(tǒng)調(diào)用
    [DllImport("libc", SetLastError = true)]
    private static extern int open(string pathname, int flags);

    [DllImport("libc", SetLastError = true)]
    private static extern int close(int fd);

    [DllImport("libc", SetLastError = true)]
    private static extern IntPtr read(int fd, byte[] buf, UIntPtr count);

    [DllImport("libc", SetLastError = true)]
    private static extern IntPtr write(int fd, byte[] buf, UIntPtr count);

    [DllImport("libc", SetLastError = true)]
    private static extern int tcgetattr(int fd, ref termios termios_p);

    [DllImport("libc", SetLastError = true)]
    private static extern int tcsetattr(int fd, int optional_actions, ref termios termios_p);

    // Linux文件操作標(biāo)志
    private const int O_RDWR = 0x02;
    private const int O_NOCTTY = 0x100;
    private const int O_NONBLOCK = 0x800;

    // termios結(jié)構(gòu)體（簡化版本）
    [StructLayout(LayoutKind.Sequential)]
    private struct termios
    {
        public uint c_iflag;
        public uint c_oflag;  
        public uint c_cflag;
        public uint c_lflag;
        public byte c_line;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
        public byte[] c_cc;
        public uint c_ispeed;
        public uint c_ospeed;
    }

    private int _fileDescriptor = -1;
    private string _devicePath;
    private bool _isOpen;
    private CancellationTokenSource _cancellationTokenSource;
    private Task _readTask;

    /// <summary>
    /// 數(shù)據(jù)接收事件
    /// </summary>
    public event Action<byte[]> DataReceived;

    /// <summary>
    /// 獲取串口是否已打開
    /// </summary>
    public bool IsOpen => _isOpen && _fileDescriptor >= 0;

    /// <summary>
    /// 打開指定的串口設(shè)備
    /// </summary>
    /// <param name="devicePath">設(shè)備路徑，例如：/dev/ttyUSB0</param>
    /// <param name="baudRate">波特率</param>
    /// <returns>成功打開返回true</returns>
    public bool Open(string devicePath, int baudRate = 9600)
    {
        try
        {
            if (_isOpen)
            {
                Close();
            }

            // 檢查設(shè)備文件是否存在
            if (!File.Exists(devicePath))
            {
                Console.WriteLine($"設(shè)備文件不存在: {devicePath}");
                return false;
            }

            // 打開設(shè)備文件
            _fileDescriptor = open(devicePath, O_RDWR | O_NOCTTY | O_NONBLOCK);
            if (_fileDescriptor < 0)
            {
                Console.WriteLine($"無法打開設(shè)備: {devicePath}，錯(cuò)誤碼: {Marshal.GetLastWin32Error()}");
                return false;
            }

            // 配置串口參數(shù)
            if (!ConfigureSerialPort(baudRate))
            {
                close(_fileDescriptor);
                _fileDescriptor = -1;
                return false;
            }

            _devicePath = devicePath;
            _isOpen = true;

            // 啟動(dòng)數(shù)據(jù)接收任務(wù)
            StartReceiveTask();

            Console.WriteLine($"成功打開串口: {devicePath}");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"打開串口失敗: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 配置串口參數(shù)
    /// </summary>
    /// <param name="baudRate">波特率</param>
    /// <returns>配置成功返回true</returns>
    private bool ConfigureSerialPort(int baudRate)
    {
        try
        {
            termios tty = new termios();
            
            // 獲取當(dāng)前終端屬性
            if (tcgetattr(_fileDescriptor, ref tty) != 0)
            {
                Console.WriteLine("獲取終端屬性失敗");
                return false;
            }

            // 配置波特率（簡化實(shí)現(xiàn)，實(shí)際應(yīng)用中需要更詳細(xì)的配置）
            // 這里只是演示，實(shí)際應(yīng)用中需要根據(jù)具體的波特率設(shè)置相應(yīng)的常量
            tty.c_cflag = 0x00001800; // 基本配置
            tty.c_iflag = 0;
            tty.c_oflag = 0;
            tty.c_lflag = 0;

            // 應(yīng)用配置
            if (tcsetattr(_fileDescriptor, 0, ref tty) != 0)
            {
                Console.WriteLine("設(shè)置終端屬性失敗");
                return false;
            }

            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"配置串口參數(shù)失敗: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 啟動(dòng)數(shù)據(jù)接收任務(wù)
    /// </summary>
    private void StartReceiveTask()
    {
        _cancellationTokenSource = new CancellationTokenSource();
        _readTask = Task.Run(() => ReceiveDataLoop(_cancellationTokenSource.Token));
    }

    /// <summary>
    /// 數(shù)據(jù)接收循環(huán)
    /// </summary>
    /// <param name="cancellationToken">取消令牌</param>
    private void ReceiveDataLoop(CancellationToken cancellationToken)
    {
        byte[] buffer = new byte[1024];
        
        while (!cancellationToken.IsCancellationRequested && _isOpen)
        {
            try
            {
                IntPtr result = read(_fileDescriptor, buffer, new UIntPtr((uint)buffer.Length));
                int bytesRead = result.ToInt32();

                if (bytesRead > 0)
                {
                    byte[] receivedData = new byte[bytesRead];
                    Array.Copy(buffer, receivedData, bytesRead);
                    DataReceived?.Invoke(receivedData);
                }
                else if (bytesRead < 0)
                {
                    // 檢查是否是EAGAIN錯(cuò)誤（非阻塞模式下的正常情況）
                    int error = Marshal.GetLastWin32Error();
                    if (error != 11) // EAGAIN
                    {
                        Console.WriteLine($"讀取數(shù)據(jù)錯(cuò)誤: {error}");
                        break;
                    }
                }

                // 短暫休眠避免過度占用CPU
                Thread.Sleep(10);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"數(shù)據(jù)接收循環(huán)異常: {ex.Message}");
                break;
            }
        }
    }

    /// <summary>
    /// 向串口寫入數(shù)據(jù)
    /// </summary>
    /// <param name="data">要發(fā)送的字節(jié)數(shù)組</param>
    /// <returns>實(shí)際發(fā)送的字節(jié)數(shù)</returns>
    public int Write(byte[] data)
    {
        try
        {
            if (!IsOpen)
            {
                Console.WriteLine("串口未打開");
                return 0;
            }

            IntPtr result = write(_fileDescriptor, data, new UIntPtr((uint)data.Length));
            int bytesWritten = result.ToInt32();

            if (bytesWritten < 0)
            {
                Console.WriteLine($"寫入數(shù)據(jù)失敗，錯(cuò)誤碼: {Marshal.GetLastWin32Error()}");
                return 0;
            }

            return bytesWritten;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"寫入數(shù)據(jù)異常: {ex.Message}");
            return 0;
        }
    }

    /// <summary>
    /// 關(guān)閉串口連接
    /// </summary>
    public void Close()
    {
        try
        {
            _isOpen = false;

            // 停止接收任務(wù)
            _cancellationTokenSource?.Cancel();
            _readTask?.Wait(1000); // 等待最多1秒

            // 關(guān)閉文件描述符
            if (_fileDescriptor >= 0)
            {
                close(_fileDescriptor);
                _fileDescriptor = -1;
            }

            Console.WriteLine("串口已關(guān)閉");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"關(guān)閉串口異常: {ex.Message}");
        }
    }

    /// <summary>
    /// 獲取可用的串口設(shè)備列表
    /// </summary>
    /// <returns>設(shè)備路徑數(shù)組</returns>
    public string[] GetAvailablePorts()
    {
        try
        {
            List<string> ports = new List<string>();

            // 掃描常見的串口設(shè)備路徑
            string[] prefixes = { "/dev/ttyUSB", "/dev/ttyACM", "/dev/ttyS", "/dev/rfcomm" };
            
            foreach (string prefix in prefixes)
            {
                for (int i = 0; i < 32; i++) // 檢查前32個(gè)設(shè)備
                {
                    string devicePath = $"{prefix}{i}";
                    if (File.Exists(devicePath))
                    {
                        ports.Add(devicePath);
                    }
                }
            }

            return ports.ToArray();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"獲取串口列表失敗: {ex.Message}");
            return new string[0];
        }
    }

    /// <summary>
    /// 讀取數(shù)據(jù)（同步方式）
    /// </summary>
    /// <param name="buffer">接收緩沖區(qū)</param>
    /// <returns>實(shí)際讀取的字節(jié)數(shù)</returns>
    public int Read(byte[] buffer)
    {
        try
        {
            if (!IsOpen)
            {
                return 0;
            }

            IntPtr result = read(_fileDescriptor, buffer, new UIntPtr((uint)buffer.Length));
            int bytesRead = result.ToInt32();

            return bytesRead > 0 ? bytesRead : 0;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"讀取數(shù)據(jù)異常: {ex.Message}");
            return 0;
        }
    }

    /// <summary>
    /// 釋放資源
    /// </summary>
    public void Dispose()
    {
        Close();
        _cancellationTokenSource?.Dispose();
    }
}

using RJCP.IO.Ports;
using System;
using System.Text;
using System.Threading.Tasks;

/// <summary>
/// 基于SerialPortStream的跨平臺(tái)串口服務(wù)實(shí)現(xiàn)
/// 提供統(tǒng)一的串口操作接口，支持Windows、Linux、macOS平臺(tái)
/// </summary>
public class SerialPortStreamService : ISerialPortService
{
    private SerialPortStream _serialPort;
    private bool _isOpen;

    /// <summary>
    /// 數(shù)據(jù)接收事件
    /// </summary>
    public event Action<byte[]> DataReceived;

    /// <summary>
    /// 獲取串口是否已打開
    /// </summary>
    public bool IsOpen => _isOpen && _serialPort?.IsOpen == true;

    /// <summary>
    /// 構(gòu)造函數(shù)
    /// </summary>
    public SerialPortStreamService()
    {
        _isOpen = false;
    }

    /// <summary>
    /// 打開串口連接
    /// </summary>
    /// <param name="portName">端口名稱</param>
    /// <param name="baudRate">波特率</param>
    /// <param name="dataBits">數(shù)據(jù)位</param>
    /// <param name="parity">校驗(yàn)位</param>
    /// <param name="stopBits">停止位</param>
    /// <returns>成功返回true</returns>
    public bool Open(string portName, int baudRate = 9600, int dataBits = 8, 
                    Parity parity = Parity.None, StopBits stopBits = StopBits.One)
    {
        try
        {
            if (_isOpen)
            {
                Close();
            }

            // 創(chuàng)建SerialPortStream實(shí)例
            _serialPort = new SerialPortStream(portName, baudRate, dataBits, parity, stopBits);
            
            // 配置緩沖區(qū)大小
            _serialPort.ReadBufferSize = 4096;
            _serialPort.WriteBufferSize = 4096;
            
            // 設(shè)置超時(shí)
            _serialPort.ReadTimeout = 1000;
            _serialPort.WriteTimeout = 1000;

            // 注冊數(shù)據(jù)接收事件
            _serialPort.DataReceived += OnDataReceived;
            _serialPort.ErrorReceived += OnErrorReceived;

            // 打開端口
            _serialPort.Open();
            _isOpen = true;

            Console.WriteLine($"成功打開串口: {portName}");
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"打開串口失敗: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 關(guān)閉串口連接
    /// </summary>
    public void Close()
    {
        try
        {
            if (_serialPort?.IsOpen == true)
            {
                _serialPort.DataReceived -= OnDataReceived;
                _serialPort.ErrorReceived -= OnErrorReceived;
                _serialPort.Close();
            }
            _isOpen = false;
            Console.WriteLine("串口已關(guān)閉");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"關(guān)閉串口時(shí)發(fā)生錯(cuò)誤: {ex.Message}");
        }
    }

    /// <summary>
    /// 寫入數(shù)據(jù)到串口
    /// </summary>
    /// <param name="data">要發(fā)送的數(shù)據(jù)</param>
    /// <returns>實(shí)際發(fā)送的字節(jié)數(shù)</returns>
    public int Write(byte[] data)
    {
        try
        {
            if (!IsOpen)
            {
                throw new InvalidOperationException("串口未打開");
            }

            _serialPort.Write(data, 0, data.Length);
            return data.Length;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"寫入數(shù)據(jù)失敗: {ex.Message}");
            return 0;
        }
    }

    /// <summary>
    /// 從串口讀取數(shù)據(jù)
    /// </summary>
    /// <param name="buffer">接收緩沖區(qū)</param>
    /// <returns>實(shí)際讀取的字節(jié)數(shù)</returns>
    public int Read(byte[] buffer)
    {
        try
        {
            if (!IsOpen)
            {
                return 0;
            }

            return _serialPort.Read(buffer, 0, buffer.Length);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"讀取數(shù)據(jù)失敗: {ex.Message}");
            return 0;
        }
    }

    /// <summary>
    /// 獲取可用的串口列表
    /// </summary>
    /// <returns>串口名稱數(shù)組</returns>
    public string[] GetAvailablePorts()
    {
        try
        {
            return SerialPortStream.GetPortNames();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"獲取串口列表失敗: {ex.Message}");
            return new string[0];
        }
    }

    /// <summary>
    /// 異步發(fā)送字符串?dāng)?shù)據(jù)
    /// </summary>
    /// <param name="text">要發(fā)送的文本</param>
    /// <returns>異步任務(wù)</returns>
    public async Task<bool> WriteStringAsync(string text)
    {
        try
        {
            if (!IsOpen)
            {
                return false;
            }

            byte[] data = Encoding.UTF8.GetBytes(text);
            await _serialPort.WriteAsync(data, 0, data.Length);
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"異步發(fā)送數(shù)據(jù)失敗: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// 數(shù)據(jù)接收事件處理器
    /// </summary>
    private void OnDataReceived(object sender, SerialDataReceivedEventArgs e)
    {
        try
        {
            SerialPortStream sp = sender as SerialPortStream;
            int bytesToRead = sp.BytesToRead;
            
            if (bytesToRead > 0)
            {
                byte[] buffer = new byte[bytesToRead];
                int bytesRead = sp.Read(buffer, 0, bytesToRead);
                
                if (bytesRead > 0)
                {
                    Array.Resize(ref buffer, bytesRead);
                    DataReceived?.Invoke(buffer);
                }
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"處理接收數(shù)據(jù)時(shí)發(fā)生錯(cuò)誤: {ex.Message}");
        }
    }

    /// <summary>
    /// 錯(cuò)誤事件處理器
    /// </summary>
    private void OnErrorReceived(object sender, SerialErrorReceivedEventArgs e)
    {
        Console.WriteLine($"串口錯(cuò)誤: {e.EventType}");
    }

    /// <summary>
    /// 釋放資源
    /// </summary>
    public void Dispose()
    {
        Close();
        _serialPort?.Dispose();
    }
}

<PackageReference Include="SerialPortStream" Version="2.4.1" />

Install-Package SerialPortStream

# 克隆倉庫
git clone https://github.com/jcurl/serialportstream.git
cd serialportstream/dll/serialunix
./build.sh

# 將編譯的庫添加到LD_LIBRARY_PATH
export LD_LIBRARY_PATH=$PWD/bin/usr/local/lib:$LD_LIBRARY_PATH

using System;
using System.IO.Ports;

/// <summary>
/// 跨平臺(tái)串口服務(wù)接口
/// 定義了所有平臺(tái)都需要實(shí)現(xiàn)的串口操作方法
/// </summary>
public interface ISerialPortService : IDisposable
{
    /// <summary>
    /// 數(shù)據(jù)接收事件
    /// </summary>
    event Action<byte[]> DataReceived;

    /// <summary>
    /// 串口是否已打開
    /// </summary>
    bool IsOpen { get; }

    /// <summary>
    /// 打開串口
    /// </summary>
    /// <param name="portName">端口名稱</param>
    /// <param name="baudRate">波特率</param>
    /// <param name="dataBits">數(shù)據(jù)位</param>
    /// <param name="parity">校驗(yàn)位</param>
    /// <param name="stopBits">停止位</param>
    /// <returns>成功返回true</returns>
    bool Open(string portName, int baudRate = 9600, int dataBits = 8, 
             Parity parity = Parity.None, StopBits stopBits = StopBits.One);

    /// <summary>
    /// 關(guān)閉串口
    /// </summary>
    void Close();

    /// <summary>
    /// 寫入數(shù)據(jù)
    /// </summary>
    /// <param name="data">要發(fā)送的數(shù)據(jù)</param>
    /// <returns>實(shí)際發(fā)送的字節(jié)數(shù)</returns>
    int Write(byte[] data);

    /// <summary>
    /// 讀取數(shù)據(jù)
    /// </summary>
    /// <param name="buffer">接收緩沖區(qū)</param>
    /// <returns>實(shí)際讀取的字節(jié)數(shù)</returns>
    int Read(byte[] buffer);

    /// <summary>
    /// 獲取可用串口列表
    /// </summary>
    /// <returns>串口名稱數(shù)組</returns>
    string[] GetAvailablePorts();
}

using System;
using System.Runtime.InteropServices;

/// <summary>
/// 串口服務(wù)工廠類
/// 根據(jù)當(dāng)前運(yùn)行平臺(tái)自動(dòng)創(chuàng)建合適的串口服務(wù)實(shí)例
/// </summary>
public static class SerialPortServiceFactory
{
    /// <summary>
    /// 創(chuàng)建適合當(dāng)前平臺(tái)的串口服務(wù)實(shí)例
    /// </summary>
    /// <param name="preferredProvider">首選的串口提供者</param>
    /// <returns>串口服務(wù)實(shí)例</returns>
    public static ISerialPortService CreateSerialPortService(SerialPortProvider preferredProvider = SerialPortProvider.Auto)
    {
        switch (preferredProvider)
        {
            case SerialPortProvider.Auto:
                return CreateAutoDetectedService();
            case SerialPortProvider.SystemIOPorts:
                return new WindowsSerialPortService();
            case SerialPortProvider.SerialPortStream:
                return new SerialPortStreamService();
            case SerialPortProvider.NativeLinux:
                if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
                    return new LinuxSerialPortService();
                else
                    throw new PlatformNotSupportedException("原生Linux實(shí)現(xiàn)僅支持Linux平臺(tái)");
            default:
                throw new ArgumentException($"不支持的串口提供者: {preferredProvider}");
        }
    }

    /// <summary>
    /// 自動(dòng)檢測并創(chuàng)建最佳的串口服務(wù)
    /// </summary>
    /// <returns>串口服務(wù)實(shí)例</returns>
    private static ISerialPortService CreateAutoDetectedService()
    {
        // 優(yōu)先級：SerialPortStream > 平臺(tái)原生實(shí)現(xiàn)
        try
        {
            // 嘗試使用SerialPortStream（最佳跨平臺(tái)方案）
            return new SerialPortStreamService();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"SerialPortStream不可用，回退到平臺(tái)原生實(shí)現(xiàn): {ex.Message}");
            
            // 回退到平臺(tái)特定實(shí)現(xiàn)
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                return new WindowsSerialPortService();
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                return new LinuxSerialPortService();
            }
            else
            {
                throw new PlatformNotSupportedException($"不支持的平臺(tái): {RuntimeInformation.OSDescription}");
            }
        }
    }

    /// <summary>
    /// 獲取當(dāng)前平臺(tái)的默認(rèn)串口前綴
    /// </summary>
    /// <returns>串口前綴字符串</returns>
    public static string GetDefaultPortPrefix()
    {
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            return "COM";
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            return "/dev/ttyUSB";
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            return "/dev/cu.usbserial";
        else
            return "UNKNOWN";
    }
}

/// <summary>
/// 串口提供者枚舉
/// </summary>
public enum SerialPortProvider
{
    Auto,                // 自動(dòng)選擇最佳實(shí)現(xiàn)
    SystemIOPorts,       // 使用System.IO.Ports
    SerialPortStream,    // 使用SerialPortStream庫
    NativeLinux         // 使用原生Linux實(shí)現(xiàn)
}

using System;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

/// <summary>
/// 跨平臺(tái)串口通訊演示窗體
/// 展示如何在WinForm中集成跨平臺(tái)串口通訊功能
/// </summary>
public partial class CrossPlatformSerialForm : Form
{
    private ISerialPortService _serialPortService;
    private StringBuilder _receivedDataBuilder;

    // 界面控件
    private ComboBox cmbPortName;
    private ComboBox cmbBaudRate;
    private ComboBox cmbDataBits;
    private ComboBox cmbParity;
    private ComboBox cmbStopBits;
    private ComboBox cmbProvider;
    private Button btnRefreshPorts;
    private Button btnOpen;
    private Button btnClose;
    private TextBox txtSendData;
    private Button btnSend;
    private TextBox txtReceiveData;
    private Button btnClearReceive;
    private Label lblStatus;
    private CheckBox chkHexDisplay;

    public CrossPlatformSerialForm()
    {
        InitializeComponent();
        InitializeSerialPortService();
        _receivedDataBuilder = new StringBuilder();
    }

    /// <summary>
    /// 初始化界面控件
    /// </summary>
    private void InitializeComponent()
    {
        this.Text = "C# WinForm跨平臺(tái)串口通訊演示";
        this.Size = new Size(800, 600);
        this.StartPosition = FormStartPosition.CenterScreen;

        // 創(chuàng)建控件
        CreateSerialPortControls();
        CreateDataControls();
        CreateStatusControls();
        
        // 布局控件
        LayoutControls();
        
        // 綁定事件
        BindEvents();
        
        // 初始化數(shù)據(jù)
        InitializeControlValues();
    }

    /// <summary>
    /// 創(chuàng)建串口配置控件
    /// </summary>
    private void CreateSerialPortControls()
    {
        // 串口名稱
        var lblPortName = new Label { Text = "串口:", Location = new Point(10, 15), Size = new Size(50, 23) };
        cmbPortName = new ComboBox { Location = new Point(70, 12), Size = new Size(120, 23), DropDownStyle = ComboBoxStyle.DropDownList };
        
        // 刷新串口按鈕
        btnRefreshPorts = new Button { Text = "刷新", Location = new Point(200, 12), Size = new Size(60, 23) };
        
        // 波特率
        var lblBaudRate = new Label { Text = "波特率:", Location = new Point(280, 15), Size = new Size(50, 23) };
        cmbBaudRate = new ComboBox { Location = new Point(340, 12), Size = new Size(80, 23), DropDownStyle = ComboBoxStyle.DropDownList };
        
        // 數(shù)據(jù)位
        var lblDataBits = new Label { Text = "數(shù)據(jù)位:", Location = new Point(430, 15), Size = new Size(50, 23) };
        cmbDataBits = new ComboBox { Location = new Point(490, 12), Size = new Size(60, 23), DropDownStyle = ComboBoxStyle.DropDownList };
        
        // 校驗(yàn)位
        var lblParity = new Label { Text = "校驗(yàn):", Location = new Point(560, 15), Size = new Size(40, 23) };
        cmbParity = new ComboBox { Location = new Point(610, 12), Size = new Size(80, 23), DropDownStyle = ComboBoxStyle.DropDownList };
        
        // 停止位
        var lblStopBits = new Label { Text = "停止位:", Location = new Point(10, 45), Size = new Size(50, 23) };
        cmbStopBits = new ComboBox { Location = new Point(70, 42), Size = new Size(80, 23), DropDownStyle = ComboBoxStyle.DropDownList };
        
        // 提供者選擇
        var lblProvider = new Label { Text = "提供者:", Location = new Point(160, 45), Size = new Size(50, 23) };
        cmbProvider = new ComboBox { Location = new Point(220, 42), Size = new Size(120, 23), DropDownStyle = ComboBoxStyle.DropDownList };
        
        // 連接控制按鈕
        btnOpen = new Button { Text = "打開串口", Location = new Point(350, 42), Size = new Size(80, 23) };
        btnClose = new Button { Text = "關(guān)閉串口", Location = new Point(440, 42), Size = new Size(80, 23), Enabled = false };
        
        // 添加到窗體
        this.Controls.AddRange(new Control[] {
            lblPortName, cmbPortName, btnRefreshPorts,
            lblBaudRate, cmbBaudRate,
            lblDataBits, cmbDataBits,
            lblParity, cmbParity,
            lblStopBits, cmbStopBits,
            lblProvider, cmbProvider,
            btnOpen, btnClose
        });
    }

    /// <summary>
    /// 創(chuàng)建數(shù)據(jù)收發(fā)控件
    /// </summary>
    private void CreateDataControls()
    {
        // 發(fā)送數(shù)據(jù)區(qū)域
        var grpSend = new GroupBox { Text = "發(fā)送數(shù)據(jù)", Location = new Point(10, 80), Size = new Size(760, 80) };
        txtSendData = new TextBox { Location = new Point(10, 25), Size = new Size(650, 23) };
        btnSend = new Button { Text = "發(fā)送", Location = new Point(670, 25), Size = new Size(80, 23) };
        grpSend.Controls.AddRange(new Control[] { txtSendData, btnSend });
        
        // 接收數(shù)據(jù)區(qū)域
        var grpReceive = new GroupBox { Text = "接收數(shù)據(jù)", Location = new Point(10, 170), Size = new Size(760, 320) };
        txtReceiveData = new TextBox {
            Location = new Point(10, 25),
            Size = new Size(740, 250),
            Multiline = true,
            ScrollBars = ScrollBars.Vertical,
            ReadOnly = true,
            Font = new Font("Consolas", 9)
        };
        btnClearReceive = new Button { Text = "清空", Location = new Point(10, 285), Size = new Size(80, 23) };
        chkHexDisplay = new CheckBox { Text = "十六進(jìn)制顯示", Location = new Point(100, 285), Size = new Size(120, 23) };
        grpReceive.Controls.AddRange(new Control[] { txtReceiveData, btnClearReceive, chkHexDisplay });
        
        this.Controls.AddRange(new Control[] { grpSend, grpReceive });
    }

    /// <summary>
    /// 創(chuàng)建狀態(tài)控件
    /// </summary>
    private void CreateStatusControls()
    {
        lblStatus = new Label {
            Text = "就緒",
            Location = new Point(10, 510),
            Size = new Size(760, 23),
            BorderStyle = BorderStyle.FixedSingle,
            TextAlign = ContentAlignment.MiddleLeft
        };
        this.Controls.Add(lblStatus);
    }

    /// <summary>
    /// 布局控件（此處省略具體布局代碼）
    /// </summary>
    private void LayoutControls()
    {
        // 實(shí)際項(xiàng)目中可以使用TableLayoutPanel或其他布局控件
        // 此處為簡化演示，直接使用絕對定位
    }

    /// <summary>
    /// 綁定事件處理器
    /// </summary>
    private void BindEvents()
    {
        btnRefreshPorts.Click += BtnRefreshPorts_Click;
        btnOpen.Click += BtnOpen_Click;
        btnClose.Click += BtnClose_Click;
        btnSend.Click += BtnSend_Click;
        btnClearReceive.Click += BtnClearReceive_Click;
        chkHexDisplay.CheckedChanged += ChkHexDisplay_CheckedChanged;
        this.FormClosing += CrossPlatformSerialForm_FormClosing;
    }

    /// <summary>
    /// 初始化控件值
    /// </summary>
    private void InitializeControlValues()
    {
        // 波特率選項(xiàng)
        cmbBaudRate.Items.AddRange(new object[] { 9600, 19200, 38400, 57600, 115200 });
        cmbBaudRate.SelectedIndex = 0;
        
        // 數(shù)據(jù)位選項(xiàng)
        cmbDataBits.Items.AddRange(new object[] { 7, 8 });
        cmbDataBits.SelectedIndex = 1;
        
        // 校驗(yàn)位選項(xiàng)
        cmbParity.Items.AddRange(Enum.GetNames(typeof(System.IO.Ports.Parity)));
        cmbParity.SelectedIndex = 0; // None
        
        // 停止位選項(xiàng)
        cmbStopBits.Items.AddRange(Enum.GetNames(typeof(System.IO.Ports.StopBits)));
        cmbStopBits.SelectedIndex = 1; // One
        
        // 提供者選項(xiàng)
        cmbProvider.Items.AddRange(Enum.GetNames(typeof(SerialPortProvider)));
        cmbProvider.SelectedIndex = 0; // Auto
        
        // 刷新串口列表
        RefreshPortList();
    }

    /// <summary>
    /// 初始化串口服務(wù)
    /// </summary>
    private void InitializeSerialPortService()
    {
        try
        {
            _serialPortService = SerialPortServiceFactory.CreateSerialPortService();
            _serialPortService.DataReceived += OnDataReceived;
            UpdateStatus("串口服務(wù)初始化成功");
        }
        catch (Exception ex)
        {
            UpdateStatus($"串口服務(wù)初始化失敗: {ex.Message}");
            MessageBox.Show($"串口服務(wù)初始化失敗: {ex.Message}", "錯(cuò)誤", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    /// <summary>
    /// 刷新串口列表
    /// </summary>
    private void RefreshPortList()
    {
        try
        {
            cmbPortName.Items.Clear();
            string[] ports = _serialPortService?.GetAvailablePorts() ?? new string[0];
            cmbPortName.Items.AddRange(ports);
            
            if (cmbPortName.Items.Count > 0)
            {
                cmbPortName.SelectedIndex = 0;
            }
            
            UpdateStatus($"發(fā)現(xiàn) {ports.Length} 個(gè)串口設(shè)備");
        }
        catch (Exception ex)
        {
            UpdateStatus($"刷新串口列表失敗: {ex.Message}");
        }
    }

    /// <summary>
    /// 數(shù)據(jù)接收事件處理器
    /// </summary>
    private void OnDataReceived(byte[] data)
    {
        // 由于事件可能在非UI線程中觸發(fā)，需要使用Invoke進(jìn)行線程安全的UI更新
        if (this.InvokeRequired)
        {
            this.Invoke(new Action<byte[]>(OnDataReceived), data);
            return;
        }

        try
        {
            string displayText;
            if (chkHexDisplay.Checked)
            {
                // 十六進(jìn)制顯示
                displayText = string.Join(" ", data.Select(b => b.ToString("X2"))) + " ";
            }
            else
            {
                // ASCII顯示
                displayText = Encoding.UTF8.GetString(data);
            }

            _receivedDataBuilder.Append(displayText);
            txtReceiveData.Text = _receivedDataBuilder.ToString();
            
            // 自動(dòng)滾動(dòng)到底部
            txtReceiveData.SelectionStart = txtReceiveData.Text.Length;
            txtReceiveData.ScrollToCaret();
            
            UpdateStatus($"接收到 {data.Length} 字節(jié)數(shù)據(jù)");
        }
        catch (Exception ex)
        {
            UpdateStatus($"處理接收數(shù)據(jù)失敗: {ex.Message}");
        }
    }

    /// <summary>
    /// 更新狀態(tài)欄信息
    /// </summary>
    private void UpdateStatus(string message)
    {
        if (lblStatus.InvokeRequired)
        {
            lblStatus.Invoke(new Action<string>(UpdateStatus), message);
            return;
        }
        
        lblStatus.Text = $"{DateTime.Now:HH:mm:ss} - {message}";
    }

    // 事件處理器實(shí)現(xiàn)
    private void BtnRefreshPorts_Click(object sender, EventArgs e)
    {
        RefreshPortList();
    }

    private async void BtnOpen_Click(object sender, EventArgs e)
    {
        try
        {
            if (cmbPortName.SelectedItem == null)
            {
                MessageBox.Show("請選擇串口", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            // 根據(jù)選擇的提供者重新創(chuàng)建服務(wù)
            var provider = (SerialPortProvider)Enum.Parse(typeof(SerialPortProvider), cmbProvider.SelectedItem.ToString());
            _serialPortService?.Dispose();
            _serialPortService = SerialPortServiceFactory.CreateSerialPortService(provider);
            _serialPortService.DataReceived += OnDataReceived;

            // 解析參數(shù)
            string portName = cmbPortName.SelectedItem.ToString();
            int baudRate = (int)cmbBaudRate.SelectedItem;
            int dataBits = (int)cmbDataBits.SelectedItem;
            var parity = (System.IO.Ports.Parity)Enum.Parse(typeof(System.IO.Ports.Parity), cmbParity.SelectedItem.ToString());
            var stopBits = (System.IO.Ports.StopBits)Enum.Parse(typeof(System.IO.Ports.StopBits), cmbStopBits.SelectedItem.ToString());

            // 異步打開串口
            bool success = await Task.Run(() => _serialPortService.Open(portName, baudRate, dataBits, parity, stopBits));

            if (success)
            {
                btnOpen.Enabled = false;
                btnClose.Enabled = true;
                btnSend.Enabled = true;
                EnableSerialPortControls(false);
                UpdateStatus($"串口 {portName} 已打開");
            }
            else
            {
                MessageBox.Show("打開串口失敗", "錯(cuò)誤", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show($"打開串口異常: {ex.Message}", "錯(cuò)誤", MessageBoxButtons.OK, MessageBoxIcon.Error);
            UpdateStatus($"打開串口異常: {ex.Message}");
        }
    }

    private void BtnClose_Click(object sender, EventArgs e)
    {
        try
        {
            _serialPortService?.Close();
            btnOpen.Enabled = true;
            btnClose.Enabled = false;
            btnSend.Enabled = false;
            EnableSerialPortControls(true);
            UpdateStatus("串口已關(guān)閉");
        }
        catch (Exception ex)
        {
            UpdateStatus($"關(guān)閉串口異常: {ex.Message}");
        }
    }

    private async void BtnSend_Click(object sender, EventArgs e)
    {
        try
        {
            if (string.IsNullOrEmpty(txtSendData.Text))
            {
                MessageBox.Show("請輸入要發(fā)送的數(shù)據(jù)", "提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            byte[] data = Encoding.UTF8.GetBytes(txtSendData.Text);
            int bytesSent = await Task.Run(() => _serialPortService.Write(data));
            
            if (bytesSent > 0)
            {
                UpdateStatus($"發(fā)送了 {bytesSent} 字節(jié)數(shù)據(jù)");
            }
            else
            {
                UpdateStatus("發(fā)送數(shù)據(jù)失敗");
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show($"發(fā)送數(shù)據(jù)異常: {ex.Message}", "錯(cuò)誤", MessageBoxButtons.OK, MessageBoxIcon.Error);
            UpdateStatus($"發(fā)送數(shù)據(jù)異常: {ex.Message}");
        }
    }

    private void BtnClearReceive_Click(object sender, EventArgs e)
    {
        _receivedDataBuilder.Clear();
        txtReceiveData.Clear();
        UpdateStatus("已清空接收數(shù)據(jù)");
    }

    private void ChkHexDisplay_CheckedChanged(object sender, EventArgs e)
    {
        // 可以在這里實(shí)現(xiàn)顯示格式切換邏輯
        UpdateStatus($"顯示格式已切換為: {(chkHexDisplay.Checked ? "十六進(jìn)制" : "ASCII")}");
    }

    private void EnableSerialPortControls(bool enabled)
    {
        cmbPortName.Enabled = enabled;
        cmbBaudRate.Enabled = enabled;
        cmbDataBits.Enabled = enabled;
        cmbParity.Enabled = enabled;
        cmbStopBits.Enabled = enabled;
        cmbProvider.Enabled = enabled;
        btnRefreshPorts.Enabled = enabled;
    }

    private void CrossPlatformSerialForm_FormClosing(object sender, FormClosingEventArgs e)
    {
        try
        {
            _serialPortService?.Dispose();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"釋放串口資源時(shí)發(fā)生錯(cuò)誤: {ex.Message}");
        }
    }
}

/// <summary>
/// 異步串口數(shù)據(jù)處理類
/// 優(yōu)化串口數(shù)據(jù)的異步讀寫性能
/// </summary>
public class AsyncSerialPortProcessor
{
    private readonly ISerialPortService _serialPort;
    private readonly SemaphoreSlim _writeSemaphore;
    private readonly CancellationTokenSource _cancellationTokenSource;
    private readonly ConcurrentQueue<byte[]> _sendQueue;
    private readonly Task _sendTask;

    public AsyncSerialPortProcessor(ISerialPortService serialPort)
    {
        _serialPort = serialPort;
        _writeSemaphore = new SemaphoreSlim(1, 1); // 確保寫操作的線程安全
        _cancellationTokenSource = new CancellationTokenSource();
        _sendQueue = new ConcurrentQueue<byte[]>();
        
        // 啟動(dòng)異步發(fā)送任務(wù)
        _sendTask = ProcessSendQueueAsync(_cancellationTokenSource.Token);
    }

    /// <summary>
    /// 異步發(fā)送數(shù)據(jù)（非阻塞）
    /// </summary>
    /// <param name="data">要發(fā)送的數(shù)據(jù)</param>
    /// <returns>發(fā)送任務(wù)</returns>
    public Task<bool> SendAsync(byte[] data)
    {
        _sendQueue.Enqueue(data);
        return Task.FromResult(true);
    }

    /// <summary>
    /// 處理發(fā)送隊(duì)列的異步任務(wù)
    /// </summary>
    private async Task ProcessSendQueueAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            try
            {
                if (_sendQueue.TryDequeue(out byte[] data))
                {
                    await _writeSemaphore.WaitAsync(cancellationToken);
                    try
                    {
                        await Task.Run(() => _serialPort.Write(data), cancellationToken);
                    }
                    finally
                    {
                        _writeSemaphore.Release();
                    }
                }
                else
                {
                    // 隊(duì)列為空時(shí)稍作延遲，避免CPU占用過高
                    await Task.Delay(1, cancellationToken);
                }
            }
            catch (OperationCanceledException)
            {
                break;
            }
            catch (Exception ex)
            {
                // 記錄錯(cuò)誤但繼續(xù)處理
                Console.WriteLine($"發(fā)送數(shù)據(jù)時(shí)發(fā)生錯(cuò)誤: {ex.Message}");
                await Task.Delay(100, cancellationToken); // 錯(cuò)誤恢復(fù)延遲
            }
        }
    }

    public void Dispose()
    {
        _cancellationTokenSource.Cancel();
        _sendTask?.Wait(5000); // 等待最多5秒
        _writeSemaphore?.Dispose();
        _cancellationTokenSource?.Dispose();
    }
}

/// <summary>
/// 內(nèi)存池優(yōu)化的串口數(shù)據(jù)緩沖區(qū)
/// 減少GC壓力，提升性能
/// </summary>
public class OptimizedSerialBuffer
{
    private readonly ArrayPool<byte> _arrayPool;
    private readonly int _bufferSize;
    
    public OptimizedSerialBuffer(int bufferSize = 4096)
    {
        _arrayPool = ArrayPool<byte>.Shared;
        _bufferSize = bufferSize;
    }

    /// <summary>
    /// 租用緩沖區(qū)
    /// </summary>
    /// <returns>租用的字節(jié)數(shù)組</returns>
    public byte[] RentBuffer()
    {
        return _arrayPool.Rent(_bufferSize);
    }

    /// <summary>
    /// 歸還緩沖區(qū)
    /// </summary>
    /// <param name="buffer">要?dú)w還的緩沖區(qū)</param>
    /// <param name="clearArray">是否清空數(shù)組內(nèi)容</param>
    public void ReturnBuffer(byte[] buffer, bool clearArray = true)
    {
        _arrayPool.Return(buffer, clearArray);
    }

    /// <summary>
    /// 優(yōu)化的數(shù)據(jù)復(fù)制方法
    /// </summary>
    /// <param name="source">源數(shù)據(jù)</param>
    /// <param name="sourceOffset">源偏移量</param>
    /// <param name="destination">目標(biāo)數(shù)據(jù)</param>
    /// <param name="destinationOffset">目標(biāo)偏移量</param>
    /// <param name="count">復(fù)制字節(jié)數(shù)</param>
    public static void FastCopy(byte[] source, int sourceOffset, byte[] destination, int destinationOffset, int count)
    {
        if (count > 0)
        {
            Buffer.BlockCopy(source, sourceOffset, destination, destinationOffset, count);
        }
    }
}

/// <summary>
/// 平臺(tái)特定的性能優(yōu)化管理器
/// </summary>
public static class PlatformPerformanceOptimizer
{
    /// <summary>
    /// 獲取推薦的緩沖區(qū)大小
    /// 根據(jù)不同平臺(tái)返回最優(yōu)的緩沖區(qū)大小
    /// </summary>
    /// <returns>推薦的緩沖區(qū)大小</returns>
    public static int GetRecommendedBufferSize()
    {
        if (PlatformDetector.IsWindows())
        {
            // Windows平臺(tái)建議使用較大的緩沖區(qū)
            return 8192;
        }
        else if (PlatformDetector.IsLinux())
        {
            // Linux平臺(tái)建議使用中等大小的緩沖區(qū)
            return 4096;
        }
        else if (PlatformDetector.IsMacOS())
        {
            // macOS平臺(tái)建議使用中等大小的緩沖區(qū)
            return 4096;
        }
        else
        {
            // 未知平臺(tái)使用默認(rèn)大小
            return 2048;
        }
    }

    /// <summary>
    /// 獲取推薦的線程池配置
    /// </summary>
    public static void OptimizeThreadPool()
    {
        // 根據(jù)CPU核心數(shù)優(yōu)化線程池
        int processorCount = Environment.ProcessorCount;
        
        // 設(shè)置最小工作線程數(shù)
        ThreadPool.SetMinThreads(processorCount, processorCount);
        
        // 設(shè)置最大工作線程數(shù)（避免過多線程導(dǎo)致上下文切換開銷）
        ThreadPool.SetMaxThreads(processorCount * 4, processorCount * 4);
    }

    /// <summary>
    /// 設(shè)置進(jìn)程優(yōu)先級（需要管理員權(quán)限）
    /// </summary>
    public static void SetHighPriority()
    {
        try
        {
            Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"設(shè)置進(jìn)程優(yōu)先級失敗: {ex.Message}");
        }
    }
}

/// <summary>
/// 跨平臺(tái)串口通訊最佳實(shí)踐指南
/// </summary>
public static class SerialPortBestPractices
{
    /// <summary>
    /// 檢查串口配置的有效性
    /// </summary>
    /// <param name="portName">串口名稱</param>
    /// <param name="baudRate">波特率</param>
    /// <returns>配置是否有效</returns>
    public static bool ValidateConfiguration(string portName, int baudRate)
    {
        // 1. 檢查串口名稱格式
        if (string.IsNullOrEmpty(portName))
            return false;

        // 2. 檢查平臺(tái)特定的串口名稱格式
        if (PlatformDetector.IsWindows())
        {
            if (!portName.StartsWith("COM", StringComparison.OrdinalIgnoreCase))
                return false;
        }
        else if (PlatformDetector.IsLinux())
        {
            if (!portName.StartsWith("/dev/tty", StringComparison.Ordinal))
                return false;
        }
        else if (PlatformDetector.IsMacOS())
        {
            if (!portName.StartsWith("/dev/cu.", StringComparison.Ordinal))
                return false;
        }

        // 3. 檢查波特率是否在有效范圍內(nèi)
        int[] validBaudRates = { 9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600 };
        if (!validBaudRates.Contains(baudRate))
        {
            Console.WriteLine($"警告: 非標(biāo)準(zhǔn)波特率 {baudRate}，可能在某些平臺(tái)上不支持");
        }

        return true;
    }

    /// <summary>
    /// 獲取推薦的超時(shí)設(shè)置
    /// </summary>
    /// <param name="baudRate">波特率</param>
    /// <returns>推薦的超時(shí)時(shí)間（毫秒）</returns>
    public static int GetRecommendedTimeout(int baudRate)
    {
        // 根據(jù)波特率計(jì)算合理的超時(shí)時(shí)間
        // 低波特率需要更長的超時(shí)時(shí)間
        if (baudRate <= 9600)
            return 5000;
        else if (baudRate <= 57600)
            return 3000;
        else if (baudRate <= 115200)
            return 2000;
        else
            return 1000;
    }

    /// <summary>
    /// 實(shí)現(xiàn)重試機(jī)制
    /// </summary>
    /// <param name="operation">要執(zhí)行的操作</param>
    /// <param name="maxRetries">最大重試次數(shù)</param>
    /// <param name="delayMs">重試間隔（毫秒）</param>
    /// <returns>操作是否成功</returns>
    public static async Task<bool> RetryOperation(Func<bool> operation, int maxRetries = 3, int delayMs = 1000)
    {
        for (int i = 0; i <= maxRetries; i++)
        {
            try
            {
                if (operation())
                    return true;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"操作失敗 (第{i + 1}次嘗試): {ex.Message}");
                
                if (i == maxRetries)
                    throw; // 最后一次重試失敗，拋出異常
            }

            if (i < maxRetries)
            {
                await Task.Delay(delayMs);
            }
        }

        return false;
    }
}

/// <summary>
/// 串口診斷工具類
/// 用于診斷和解決常見的串口問題
/// </summary>
public static class SerialPortDiagnostics
{
    /// <summary>
    /// 診斷串口無法打開的問題
    /// </summary>
    /// <param name="portName">串口名稱</param>
    /// <returns>診斷結(jié)果和建議</returns>
    public static string DiagnosePortOpenFailure(string portName)
    {
        var issues = new List<string>();
        var suggestions = new List<string>();

        try
        {
            // 1. 檢查串口是否存在
            string[] availablePorts = SerialPort.GetPortNames();
            if (!availablePorts.Contains(portName))
            {
                issues.Add($"串口 {portName} 不存在");
                suggestions.Add($"可用串口: {string.Join(", ", availablePorts)}");
            }

            // 2. 平臺(tái)特定檢查
            if (PlatformDetector.IsLinux() || PlatformDetector.IsMacOS())
            {
                // 檢查權(quán)限
                if (!CheckUnixPortPermissions(portName))
                {
                    issues.Add("權(quán)限不足");
                    suggestions.Add($"嘗試運(yùn)行: sudo chmod 666 {portName}");
                    suggestions.Add("或?qū)⒂脩籼砑拥絛ialout組: sudo usermod -a -G dialout $USER");
                }
            }

            // 3. 檢查是否被其他程序占用
            if (IsPortInUse(portName))
            {
                issues.Add("串口可能被其他程序占用");
                suggestions.Add("關(guān)閉可能占用串口的其他程序");
                suggestions.Add("使用 lsof 命令檢查串口占用情況（Linux/macOS）");
            }

        }
        catch (Exception ex)
        {
            issues.Add($"診斷過程中發(fā)生錯(cuò)誤: {ex.Message}");
        }

        string result = "串口診斷結(jié)果:\n";
        result += "問題:\n" + string.Join("\n", issues.Select(i => $"  - {i}"));
        result += "\n建議:\n" + string.Join("\n", suggestions.Select(s => $"  - {s}"));

        return result;
    }

    /// <summary>
    /// 檢查Unix系統(tǒng)上的串口權(quán)限
    /// </summary>
    private static bool CheckUnixPortPermissions(string portName)
    {
        try
        {
            var fileInfo = new FileInfo(portName);
            return fileInfo.Exists; // 簡化的權(quán)限檢查
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// 檢查串口是否被占用
    /// </summary>
    private static bool IsPortInUse(string portName)
    {
        try
        {
            using (var testPort = new SerialPort(portName))
            {
                testPort.Open();
                testPort.Close();
                return false; // 能夠打開說明沒有被占用
            }
        }
        catch
        {
            return true; // 無法打開可能是被占用
        }
    }
}

/// <summary>
/// 數(shù)據(jù)完整性檢查器
/// 用于檢測和處理數(shù)據(jù)丟失或亂碼問題
/// </summary>
public class DataIntegrityChecker
{
    private readonly Queue<byte> _dataBuffer;
    private readonly object _bufferLock;
    private int _expectedSequence;

    public DataIntegrityChecker()
    {
        _dataBuffer = new Queue<byte>();
        _bufferLock = new object();
        _expectedSequence = 0;
    }

    /// <summary>
    /// 處理接收到的數(shù)據(jù)
    /// </summary>
    /// <param name="data">接收到的原始數(shù)據(jù)</param>
    /// <returns>處理后的完整數(shù)據(jù)包</returns>
    public List<byte[]> ProcessReceivedData(byte[] data)
    {
        var completePackets = new List<byte[]>();

        lock (_bufferLock)
        {
            // 將新數(shù)據(jù)添加到緩沖區(qū)
            foreach (byte b in data)
            {
                _dataBuffer.Enqueue(b);
            }

            // 嘗試從緩沖區(qū)中提取完整的數(shù)據(jù)包
            while (TryExtractPacket(out byte[] packet))
            {
                if (ValidatePacket(packet))
                {
                    completePackets.Add(packet);
                }
                else
                {
                    Console.WriteLine("檢測到損壞的數(shù)據(jù)包，已丟棄");
                }
            }
        }

        return completePackets;
    }

    /// <summary>
    /// 嘗試從緩沖區(qū)提取完整數(shù)據(jù)包
    /// </summary>
    private bool TryExtractPacket(out byte[] packet)
    {
        packet = null;

        // 簡化的數(shù)據(jù)包提取邏輯（假設(shè)固定長度的數(shù)據(jù)包）
        const int packetLength = 10;
        
        if (_dataBuffer.Count >= packetLength)
        {
            packet = new byte[packetLength];
            for (int i = 0; i < packetLength; i++)
            {
                packet[i] = _dataBuffer.Dequeue();
            }
            return true;
        }

        return false;
    }

    /// <summary>
    /// 驗(yàn)證數(shù)據(jù)包的完整性
    /// </summary>
    private bool ValidatePacket(byte[] packet)
    {
        // 實(shí)現(xiàn)校驗(yàn)和驗(yàn)證
        if (packet.Length < 2) return false;

        byte calculatedChecksum = 0;
        for (int i = 0; i < packet.Length - 1; i++)
        {
            calculatedChecksum ^= packet[i];
        }

        return calculatedChecksum == packet[packet.Length - 1];
    }
}

/// <summary>
/// 跨平臺(tái)兼容性管理器
/// 處理不同平臺(tái)間的差異和兼容性問題
/// </summary>
public static class CrossPlatformCompatibility
{
    /// <summary>
    /// 獲取平臺(tái)特定的串口配置
    /// </summary>
    /// <param name="portName">串口名稱</param>
    /// <returns>平臺(tái)優(yōu)化的配置</returns>
    public static SerialPortConfig GetPlatformOptimizedConfig(string portName)
    {
        var config = new SerialPortConfig();

        if (PlatformDetector.IsWindows())
        {
            // Windows平臺(tái)優(yōu)化配置
            config.ReadBufferSize = 8192;
            config.WriteBufferSize = 4096;
            config.ReadTimeout = 1000;
            config.WriteTimeout = 1000;
            config.DtrEnable = false;
            config.RtsEnable = false;
        }
        else if (PlatformDetector.IsLinux())
        {
            // Linux平臺(tái)優(yōu)化配置
            config.ReadBufferSize = 4096;
            config.WriteBufferSize = 2048;
            config.ReadTimeout = 2000;
            config.WriteTimeout = 2000;
            config.DtrEnable = true; // Linux上通常需要啟用DTR
            config.RtsEnable = true;
        }
        else if (PlatformDetector.IsMacOS())
        {
            // macOS平臺(tái)優(yōu)化配置
            config.ReadBufferSize = 4096;
            config.WriteBufferSize = 2048;
            config.ReadTimeout = 1500;
            config.WriteTimeout = 1500;
            config.DtrEnable = true;
            config.RtsEnable = false;
        }

        return config;
    }

    /// <summary>
    /// 平臺(tái)特定的串口名稱轉(zhuǎn)換
    /// </summary>
    /// <param name="genericPortName">通用串口名稱</param>
    /// <returns>平臺(tái)特定的串口名稱</returns>
    public static string ConvertPortName(string genericPortName)
    {
        if (PlatformDetector.IsWindows())
        {
            // Windows: COM1, COM2, ...
            if (!genericPortName.StartsWith("COM"))
            {
                if (int.TryParse(genericPortName, out int portNumber))
                {
                    return $"COM{portNumber}";
                }
            }
        }
        else if (PlatformDetector.IsLinux())
        {
            // Linux: /dev/ttyUSB0, /dev/ttyACM0, ...
            if (!genericPortName.StartsWith("/dev/"))
            {
                if (int.TryParse(genericPortName, out int portNumber))
                {
                    return $"/dev/ttyUSB{portNumber}";
                }
            }
        }
        else if (PlatformDetector.IsMacOS())
        {
            // macOS: /dev/cu.usbserial-xxx
            if (!genericPortName.StartsWith("/dev/"))
            {
                if (int.TryParse(genericPortName, out int portNumber))
                {
                    return $"/dev/cu.usbserial-{portNumber:D4}";
                }
            }
        }

        return genericPortName;
    }
}

/// <summary>
/// 串口配置類
/// </summary>
public class SerialPortConfig
{
    public int ReadBufferSize { get; set; } = 4096;
    public int WriteBufferSize { get; set; } = 2048;
    public int ReadTimeout { get; set; } = 1000;
    public int WriteTimeout { get; set; } = 1000;
    public bool DtrEnable { get; set; } = false;
    public bool RtsEnable { get; set; } = false;
}