C# WinForm实现跨平台串口通讯的解决方案

/// <summary>
/// 平台检测服务类
/// 用于识别当前运行的操作系统平台
/// </summary>
public static class platformdetector
{
    /// <summary>
    /// 检测当前是否为windows平台
    /// </summary>
    /// <returns>如果是windows平台返回true，否则返回false</returns>
    public static bool iswindows()
    {
        return runtimeinformation.isosplatform(osplatform.windows);
    }

    /// <summary>
    /// 检测当前是否为linux平台
    /// </summary>
    /// <returns>如果是linux平台返回true，否则返回false</returns>
    public static bool islinux()
    {
        return runtimeinformation.isosplatform(osplatform.linux);
    }

    /// <summary>
    /// 检测当前是否为macos平台
    /// </summary>
    /// <returns>如果是macos平台返回true，否则返回false</returns>
    public static bool ismacos()
    {
        return runtimeinformation.isosplatform(osplatform.osx);
    }

    /// <summary>
    /// 获取当前平台的串口路径前缀
    /// </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("不支持的操作系统平台");
    }
}

using system;
using system.io.ports;
using system.threading.tasks;
using system.windows.forms;

/// <summary>
/// windows平台串口通讯实现类
/// 基于system.io.ports.serialport的windows原生实现
/// </summary>
public class windowsserialportservice : iserialportservice
{
    private serialport _serialport;
    private bool _isopen;

    /// <summary>
    /// 数据接收事件
    /// 当有数据到达时触发此事件
    /// </summary>
    public event action<byte[]> datareceived;

    /// <summary>
    /// 获取串口是否已打开
    /// </summary>
    public bool isopen => _isopen && _serialport?.isopen == true;

    /// <summary>
    /// 构造函数，初始化windows串口服务
    /// </summary>
    public windowsserialportservice()
    {
        _serialport = new serialport();
        _isopen = false;
    }

    /// <summary>
    /// 打开指定的串口
    /// </summary>
    /// <param name="portname">com端口名称，例如：com1, com2</param>
    /// <param name="baudrate">波特率，默认9600</param>
    /// <param name="databits">数据位，默认8位</param>
    /// <param name="parity">校验位，默认无校验</param>
    /// <param name="stopbits">停止位，默认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(); // 如果已经打开，先关闭
            }

            // 配置串口参数
            _serialport.portname = portname;
            _serialport.baudrate = baudrate;
            _serialport.databits = databits;
            _serialport.parity = parity;
            _serialport.stopbits = stopbits;
            
            // 设置超时时间
            _serialport.readtimeout = 1000;
            _serialport.writetimeout = 1000;
            
            // 启用数据到达事件
            _serialport.datareceived += serialport_datareceived;

            // 打开串口
            _serialport.open();
            _isopen = true;

            return true;
        }
        catch (exception ex)
        {
            // 记录错误日志
            messagebox.show($"打开串口失败: {ex.message}", "错误", 
                          messageboxbuttons.ok, messageboxicon.error);
            return false;
        }
    }

    /// <summary>
    /// 关闭串口连接
    /// </summary>
    public void close()
    {
        try
        {
            if (_serialport?.isopen == true)
            {
                _serialport.datareceived -= serialport_datareceived;
                _serialport.close();
            }
            _isopen = false;
        }
        catch (exception ex)
        {
            // 记录关闭串口时的错误
            console.writeline($"关闭串口时发生错误: {ex.message}");
        }
    }

    /// <summary>
    /// 向串口写入数据
    /// </summary>
    /// <param name="data">要发送的字节数组</param>
    /// <returns>实际发送的字节数</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($"写入数据失败: {ex.message}");
            return 0;
        }
    }

    /// <summary>
    /// 从串口读取数据
    /// </summary>
    /// <param name="buffer">接收数据的缓冲区</param>
    /// <returns>实际读取的字节数</returns>
    public int read(byte[] buffer)
    {
        try
        {
            if (!isopen)
            {
                return 0;
            }

            return _serialport.read(buffer, 0, buffer.length);
        }
        catch (timeoutexception)
        {
            // 读取超时是正常现象，返回0
            return 0;
        }
        catch (exception ex)
        {
            console.writeline($"读取数据失败: {ex.message}");
            return 0;
        }
    }

    /// <summary>
    /// 获取系统中可用的串口列表
    /// </summary>
    /// <returns>可用串口名称数组</returns>
    public string[] getavailableports()
    {
        try
        {
            return serialport.getportnames();
        }
        catch (exception ex)
        {
            console.writeline($"获取串口列表失败: {ex.message}");
            return new string[0];
        }
    }

    /// <summary>
    /// 串口数据接收事件处理器
    /// </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)
                {
                    // 调整数组大小以匹配实际读取的数据
                    array.resize(ref buffer, bytesread);
                    datareceived?.invoke(buffer);
                }
            }
        }
        catch (exception ex)
        {
            console.writeline($"接收数据时发生错误: {ex.message}");
        }
    }

    /// <summary>
    /// 释放资源
    /// </summary>
    public void dispose()
    {
        close();
        _serialport?.dispose();
    }
}

using system.management;
using system.collections.generic;

/// <summary>
/// windows设备信息查询类
/// 用于获取详细的串口设备信息
/// </summary>
public class windowsdevicemanager
{
    /// <summary>
    /// 串口设备信息结构
    /// </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查询获取详细的串口设备信息
    /// </summary>
    /// <returns>串口设备信息列表</returns>
    public static list<serialportinfo> getdetailedportinfo()
    {
        list<serialportinfo> portinfolist = new list<serialportinfo>();

        try
        {
            // 使用wmi查询串口设备
            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;
        }
    }
}

# 查看当前用户所属的组
groups $user

# 将用户添加到dialout组以获取串口访问权限
sudo usermod -a -g dialout $user

# 临时修改串口设备权限（重启后失效）
sudo chmod 666 /dev/ttyusb0

using system;
using system.io;
using system.runtime.interopservices;
using system.threading;
using system.threading.tasks;

/// <summary>
/// linux平台串口通讯实现类
/// 使用底层文件操作方式实现串口通讯
/// </summary>
public class linuxserialportservice : iserialportservice
{
    // p/invoke 声明linux系统调用
    [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文件操作标志
    private const int o_rdwr = 0x02;
    private const int o_noctty = 0x100;
    private const int o_nonblock = 0x800;

    // termios结构体（简化版本）
    [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>
    /// 数据接收事件
    /// </summary>
    public event action<byte[]> datareceived;

    /// <summary>
    /// 获取串口是否已打开
    /// </summary>
    public bool isopen => _isopen && _filedescriptor >= 0;

    /// <summary>
    /// 打开指定的串口设备
    /// </summary>
    /// <param name="devicepath">设备路径，例如：/dev/ttyusb0</param>
    /// <param name="baudrate">波特率</param>
    /// <returns>成功打开返回true</returns>
    public bool open(string devicepath, int baudrate = 9600)
    {
        try
        {
            if (_isopen)
            {
                close();
            }

            // 检查设备文件是否存在
            if (!file.exists(devicepath))
            {
                console.writeline($"设备文件不存在: {devicepath}");
                return false;
            }

            // 打开设备文件
            _filedescriptor = open(devicepath, o_rdwr | o_noctty | o_nonblock);
            if (_filedescriptor < 0)
            {
                console.writeline($"无法打开设备: {devicepath}，错误码: {marshal.getlastwin32error()}");
                return false;
            }

            // 配置串口参数
            if (!configureserialport(baudrate))
            {
                close(_filedescriptor);
                _filedescriptor = -1;
                return false;
            }

            _devicepath = devicepath;
            _isopen = true;

            // 启动数据接收任务
            startreceivetask();

            console.writeline($"成功打开串口: {devicepath}");
            return true;
        }
        catch (exception ex)
        {
            console.writeline($"打开串口失败: {ex.message}");
            return false;
        }
    }

    /// <summary>
    /// 配置串口参数
    /// </summary>
    /// <param name="baudrate">波特率</param>
    /// <returns>配置成功返回true</returns>
    private bool configureserialport(int baudrate)
    {
        try
        {
            termios tty = new termios();
            
            // 获取当前终端属性
            if (tcgetattr(_filedescriptor, ref tty) != 0)
            {
                console.writeline("获取终端属性失败");
                return false;
            }

            // 配置波特率（简化实现，实际应用中需要更详细的配置）
            // 这里只是演示，实际应用中需要根据具体的波特率设置相应的常量
            tty.c_cflag = 0x00001800; // 基本配置
            tty.c_iflag = 0;
            tty.c_oflag = 0;
            tty.c_lflag = 0;

            // 应用配置
            if (tcsetattr(_filedescriptor, 0, ref tty) != 0)
            {
                console.writeline("设置终端属性失败");
                return false;
            }

            return true;
        }
        catch (exception ex)
        {
            console.writeline($"配置串口参数失败: {ex.message}");
            return false;
        }
    }

    /// <summary>
    /// 启动数据接收任务
    /// </summary>
    private void startreceivetask()
    {
        _cancellationtokensource = new cancellationtokensource();
        _readtask = task.run(() => receivedataloop(_cancellationtokensource.token));
    }

    /// <summary>
    /// 数据接收循环
    /// </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错误（非阻塞模式下的正常情况）
                    int error = marshal.getlastwin32error();
                    if (error != 11) // eagain
                    {
                        console.writeline($"读取数据错误: {error}");
                        break;
                    }
                }

                // 短暂休眠避免过度占用cpu
                thread.sleep(10);
            }
            catch (exception ex)
            {
                console.writeline($"数据接收循环异常: {ex.message}");
                break;
            }
        }
    }

    /// <summary>
    /// 向串口写入数据
    /// </summary>
    /// <param name="data">要发送的字节数组</param>
    /// <returns>实际发送的字节数</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($"写入数据失败，错误码: {marshal.getlastwin32error()}");
                return 0;
            }

            return byteswritten;
        }
        catch (exception ex)
        {
            console.writeline($"写入数据异常: {ex.message}");
            return 0;
        }
    }

    /// <summary>
    /// 关闭串口连接
    /// </summary>
    public void close()
    {
        try
        {
            _isopen = false;

            // 停止接收任务
            _cancellationtokensource?.cancel();
            _readtask?.wait(1000); // 等待最多1秒

            // 关闭文件描述符
            if (_filedescriptor >= 0)
            {
                close(_filedescriptor);
                _filedescriptor = -1;
            }

            console.writeline("串口已关闭");
        }
        catch (exception ex)
        {
            console.writeline($"关闭串口异常: {ex.message}");
        }
    }

    /// <summary>
    /// 获取可用的串口设备列表
    /// </summary>
    /// <returns>设备路径数组</returns>
    public string[] getavailableports()
    {
        try
        {
            list<string> ports = new list<string>();

            // 扫描常见的串口设备路径
            string[] prefixes = { "/dev/ttyusb", "/dev/ttyacm", "/dev/ttys", "/dev/rfcomm" };
            
            foreach (string prefix in prefixes)
            {
                for (int i = 0; i < 32; i++) // 检查前32个设备
                {
                    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>
    /// 读取数据（同步方式）
    /// </summary>
    /// <param name="buffer">接收缓冲区</param>
    /// <returns>实际读取的字节数</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($"读取数据异常: {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的跨平台串口服务实现
/// 提供统一的串口操作接口，支持windows、linux、macos平台
/// </summary>
public class serialportstreamservice : iserialportservice
{
    private serialportstream _serialport;
    private bool _isopen;

    /// <summary>
    /// 数据接收事件
    /// </summary>
    public event action<byte[]> datareceived;

    /// <summary>
    /// 获取串口是否已打开
    /// </summary>
    public bool isopen => _isopen && _serialport?.isopen == true;

    /// <summary>
    /// 构造函数
    /// </summary>
    public serialportstreamservice()
    {
        _isopen = false;
    }

    /// <summary>
    /// 打开串口连接
    /// </summary>
    /// <param name="portname">端口名称</param>
    /// <param name="baudrate">波特率</param>
    /// <param name="databits">数据位</param>
    /// <param name="parity">校验位</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();
            }

            // 创建serialportstream实例
            _serialport = new serialportstream(portname, baudrate, databits, parity, stopbits);
            
            // 配置缓冲区大小
            _serialport.readbuffersize = 4096;
            _serialport.writebuffersize = 4096;
            
            // 设置超时
            _serialport.readtimeout = 1000;
            _serialport.writetimeout = 1000;

            // 注册数据接收事件
            _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>
    /// 关闭串口连接
    /// </summary>
    public void close()
    {
        try
        {
            if (_serialport?.isopen == true)
            {
                _serialport.datareceived -= ondatareceived;
                _serialport.errorreceived -= onerrorreceived;
                _serialport.close();
            }
            _isopen = false;
            console.writeline("串口已关闭");
        }
        catch (exception ex)
        {
            console.writeline($"关闭串口时发生错误: {ex.message}");
        }
    }

    /// <summary>
    /// 写入数据到串口
    /// </summary>
    /// <param name="data">要发送的数据</param>
    /// <returns>实际发送的字节数</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($"写入数据失败: {ex.message}");
            return 0;
        }
    }

    /// <summary>
    /// 从串口读取数据
    /// </summary>
    /// <param name="buffer">接收缓冲区</param>
    /// <returns>实际读取的字节数</returns>
    public int read(byte[] buffer)
    {
        try
        {
            if (!isopen)
            {
                return 0;
            }

            return _serialport.read(buffer, 0, buffer.length);
        }
        catch (exception ex)
        {
            console.writeline($"读取数据失败: {ex.message}");
            return 0;
        }
    }

    /// <summary>
    /// 获取可用的串口列表
    /// </summary>
    /// <returns>串口名称数组</returns>
    public string[] getavailableports()
    {
        try
        {
            return serialportstream.getportnames();
        }
        catch (exception ex)
        {
            console.writeline($"获取串口列表失败: {ex.message}");
            return new string[0];
        }
    }

    /// <summary>
    /// 异步发送字符串数据
    /// </summary>
    /// <param name="text">要发送的文本</param>
    /// <returns>异步任务</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($"异步发送数据失败: {ex.message}");
            return false;
        }
    }

    /// <summary>
    /// 数据接收事件处理器
    /// </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($"处理接收数据时发生错误: {ex.message}");
        }
    }

    /// <summary>
    /// 错误事件处理器
    /// </summary>
    private void onerrorreceived(object sender, serialerrorreceivedeventargs e)
    {
        console.writeline($"串口错误: {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>
/// 跨平台串口服务接口
/// 定义了所有平台都需要实现的串口操作方法
/// </summary>
public interface iserialportservice : idisposable
{
    /// <summary>
    /// 数据接收事件
    /// </summary>
    event action<byte[]> datareceived;

    /// <summary>
    /// 串口是否已打开
    /// </summary>
    bool isopen { get; }

    /// <summary>
    /// 打开串口
    /// </summary>
    /// <param name="portname">端口名称</param>
    /// <param name="baudrate">波特率</param>
    /// <param name="databits">数据位</param>
    /// <param name="parity">校验位</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>
    /// 关闭串口
    /// </summary>
    void close();

    /// <summary>
    /// 写入数据
    /// </summary>
    /// <param name="data">要发送的数据</param>
    /// <returns>实际发送的字节数</returns>
    int write(byte[] data);

    /// <summary>
    /// 读取数据
    /// </summary>
    /// <param name="buffer">接收缓冲区</param>
    /// <returns>实际读取的字节数</returns>
    int read(byte[] buffer);

    /// <summary>
    /// 获取可用串口列表
    /// </summary>
    /// <returns>串口名称数组</returns>
    string[] getavailableports();
}

using system;
using system.runtime.interopservices;

/// <summary>
/// 串口服务工厂类
/// 根据当前运行平台自动创建合适的串口服务实例
/// </summary>
public static class serialportservicefactory
{
    /// <summary>
    /// 创建适合当前平台的串口服务实例
    /// </summary>
    /// <param name="preferredprovider">首选的串口提供者</param>
    /// <returns>串口服务实例</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实现仅支持linux平台");
            default:
                throw new argumentexception($"不支持的串口提供者: {preferredprovider}");
        }
    }

    /// <summary>
    /// 自动检测并创建最佳的串口服务
    /// </summary>
    /// <returns>串口服务实例</returns>
    private static iserialportservice createautodetectedservice()
    {
        // 优先级：serialportstream > 平台原生实现
        try
        {
            // 尝试使用serialportstream（最佳跨平台方案）
            return new serialportstreamservice();
        }
        catch (exception ex)
        {
            console.writeline($"serialportstream不可用，回退到平台原生实现: {ex.message}");
            
            // 回退到平台特定实现
            if (runtimeinformation.isosplatform(osplatform.windows))
            {
                return new windowsserialportservice();
            }
            else if (runtimeinformation.isosplatform(osplatform.linux))
            {
                return new linuxserialportservice();
            }
            else
            {
                throw new platformnotsupportedexception($"不支持的平台: {runtimeinformation.osdescription}");
            }
        }
    }

    /// <summary>
    /// 获取当前平台的默认串口前缀
    /// </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,                // 自动选择最佳实现
    systemioports,       // 使用system.io.ports
    serialportstream,    // 使用serialportstream库
    nativelinux         // 使用原生linux实现
}

using system;
using system.drawing;
using system.linq;
using system.text;
using system.threading.tasks;
using system.windows.forms;

/// <summary>
/// 跨平台串口通讯演示窗体
/// 展示如何在winform中集成跨平台串口通讯功能
/// </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跨平台串口通讯演示";
        this.size = new size(800, 600);
        this.startposition = formstartposition.centerscreen;

        // 创建控件
        createserialportcontrols();
        createdatacontrols();
        createstatuscontrols();
        
        // 布局控件
        layoutcontrols();
        
        // 绑定事件
        bindevents();
        
        // 初始化数据
        initializecontrolvalues();
    }

    /// <summary>
    /// 创建串口配置控件
    /// </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 };
        
        // 数据位
        var lbldatabits = new label { text = "数据位:", 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 };
        
        // 校验位
        var lblparity = new label { text = "校验:", 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 = "关闭串口", 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>
    /// 创建数据收发控件
    /// </summary>
    private void createdatacontrols()
    {
        // 发送数据区域
        var grpsend = new groupbox { text = "发送数据", 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 = "发送", location = new point(670, 25), size = new size(80, 23) };
        grpsend.controls.addrange(new control[] { txtsenddata, btnsend });
        
        // 接收数据区域
        var grpreceive = new groupbox { text = "接收数据", 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 = "十六进制显示", 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>
    /// 创建状态控件
    /// </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()
    {
        // 实际项目中可以使用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()
    {
        // 波特率选项
        cmbbaudrate.items.addrange(new object[] { 9600, 19200, 38400, 57600, 115200 });
        cmbbaudrate.selectedindex = 0;
        
        // 数据位选项
        cmbdatabits.items.addrange(new object[] { 7, 8 });
        cmbdatabits.selectedindex = 1;
        
        // 校验位选项
        cmbparity.items.addrange(enum.getnames(typeof(system.io.ports.parity)));
        cmbparity.selectedindex = 0; // none
        
        // 停止位选项
        cmbstopbits.items.addrange(enum.getnames(typeof(system.io.ports.stopbits)));
        cmbstopbits.selectedindex = 1; // one
        
        // 提供者选项
        cmbprovider.items.addrange(enum.getnames(typeof(serialportprovider)));
        cmbprovider.selectedindex = 0; // auto
        
        // 刷新串口列表
        refreshportlist();
    }

    /// <summary>
    /// 初始化串口服务
    /// </summary>
    private void initializeserialportservice()
    {
        try
        {
            _serialportservice = serialportservicefactory.createserialportservice();
            _serialportservice.datareceived += ondatareceived;
            updatestatus("串口服务初始化成功");
        }
        catch (exception ex)
        {
            updatestatus($"串口服务初始化失败: {ex.message}");
            messagebox.show($"串口服务初始化失败: {ex.message}", "错误", 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($"发现 {ports.length} 个串口设备");
        }
        catch (exception ex)
        {
            updatestatus($"刷新串口列表失败: {ex.message}");
        }
    }

    /// <summary>
    /// 数据接收事件处理器
    /// </summary>
    private void ondatareceived(byte[] data)
    {
        // 由于事件可能在非ui线程中触发，需要使用invoke进行线程安全的ui更新
        if (this.invokerequired)
        {
            this.invoke(new action<byte[]>(ondatareceived), data);
            return;
        }

        try
        {
            string displaytext;
            if (chkhexdisplay.checked)
            {
                // 十六进制显示
                displaytext = string.join(" ", data.select(b => b.tostring("x2"))) + " ";
            }
            else
            {
                // ascii显示
                displaytext = encoding.utf8.getstring(data);
            }

            _receiveddatabuilder.append(displaytext);
            txtreceivedata.text = _receiveddatabuilder.tostring();
            
            // 自动滚动到底部
            txtreceivedata.selectionstart = txtreceivedata.text.length;
            txtreceivedata.scrolltocaret();
            
            updatestatus($"接收到 {data.length} 字节数据");
        }
        catch (exception ex)
        {
            updatestatus($"处理接收数据失败: {ex.message}");
        }
    }

    /// <summary>
    /// 更新状态栏信息
    /// </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}";
    }

    // 事件处理器实现
    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;
            }

            // 根据选择的提供者重新创建服务
            var provider = (serialportprovider)enum.parse(typeof(serialportprovider), cmbprovider.selecteditem.tostring());
            _serialportservice?.dispose();
            _serialportservice = serialportservicefactory.createserialportservice(provider);
            _serialportservice.datareceived += ondatareceived;

            // 解析参数
            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("打开串口失败", "错误", messageboxbuttons.ok, messageboxicon.error);
            }
        }
        catch (exception ex)
        {
            messagebox.show($"打开串口异常: {ex.message}", "错误", 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("串口已关闭");
        }
        catch (exception ex)
        {
            updatestatus($"关闭串口异常: {ex.message}");
        }
    }

    private async void btnsend_click(object sender, eventargs e)
    {
        try
        {
            if (string.isnullorempty(txtsenddata.text))
            {
                messagebox.show("请输入要发送的数据", "提示", messageboxbuttons.ok, messageboxicon.warning);
                return;
            }

            byte[] data = encoding.utf8.getbytes(txtsenddata.text);
            int bytessent = await task.run(() => _serialportservice.write(data));
            
            if (bytessent > 0)
            {
                updatestatus($"发送了 {bytessent} 字节数据");
            }
            else
            {
                updatestatus("发送数据失败");
            }
        }
        catch (exception ex)
        {
            messagebox.show($"发送数据异常: {ex.message}", "错误", messageboxbuttons.ok, messageboxicon.error);
            updatestatus($"发送数据异常: {ex.message}");
        }
    }

    private void btnclearreceive_click(object sender, eventargs e)
    {
        _receiveddatabuilder.clear();
        txtreceivedata.clear();
        updatestatus("已清空接收数据");
    }

    private void chkhexdisplay_checkedchanged(object sender, eventargs e)
    {
        // 可以在这里实现显示格式切换逻辑
        updatestatus($"显示格式已切换为: {(chkhexdisplay.checked ? "十六进制" : "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($"释放串口资源时发生错误: {ex.message}");
        }
    }
}

/// <summary>
/// 异步串口数据处理类
/// 优化串口数据的异步读写性能
/// </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[]>();
        
        // 启动异步发送任务
        _sendtask = processsendqueueasync(_cancellationtokensource.token);
    }

    /// <summary>
    /// 异步发送数据（非阻塞）
    /// </summary>
    /// <param name="data">要发送的数据</param>
    /// <returns>发送任务</returns>
    public task<bool> sendasync(byte[] data)
    {
        _sendqueue.enqueue(data);
        return task.fromresult(true);
    }

    /// <summary>
    /// 处理发送队列的异步任务
    /// </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
                {
                    // 队列为空时稍作延迟，避免cpu占用过高
                    await task.delay(1, cancellationtoken);
                }
            }
            catch (operationcanceledexception)
            {
                break;
            }
            catch (exception ex)
            {
                // 记录错误但继续处理
                console.writeline($"发送数据时发生错误: {ex.message}");
                await task.delay(100, cancellationtoken); // 错误恢复延迟
            }
        }
    }

    public void dispose()
    {
        _cancellationtokensource.cancel();
        _sendtask?.wait(5000); // 等待最多5秒
        _writesemaphore?.dispose();
        _cancellationtokensource?.dispose();
    }
}

/// <summary>
/// 内存池优化的串口数据缓冲区
/// 减少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>
    /// 租用缓冲区
    /// </summary>
    /// <returns>租用的字节数组</returns>
    public byte[] rentbuffer()
    {
        return _arraypool.rent(_buffersize);
    }

    /// <summary>
    /// 归还缓冲区
    /// </summary>
    /// <param name="buffer">要归还的缓冲区</param>
    /// <param name="cleararray">是否清空数组内容</param>
    public void returnbuffer(byte[] buffer, bool cleararray = true)
    {
        _arraypool.return(buffer, cleararray);
    }

    /// <summary>
    /// 优化的数据复制方法
    /// </summary>
    /// <param name="source">源数据</param>
    /// <param name="sourceoffset">源偏移量</param>
    /// <param name="destination">目标数据</param>
    /// <param name="destinationoffset">目标偏移量</param>
    /// <param name="count">复制字节数</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>
/// 平台特定的性能优化管理器
/// </summary>
public static class platformperformanceoptimizer
{
    /// <summary>
    /// 获取推荐的缓冲区大小
    /// 根据不同平台返回最优的缓冲区大小
    /// </summary>
    /// <returns>推荐的缓冲区大小</returns>
    public static int getrecommendedbuffersize()
    {
        if (platformdetector.iswindows())
        {
            // windows平台建议使用较大的缓冲区
            return 8192;
        }
        else if (platformdetector.islinux())
        {
            // linux平台建议使用中等大小的缓冲区
            return 4096;
        }
        else if (platformdetector.ismacos())
        {
            // macos平台建议使用中等大小的缓冲区
            return 4096;
        }
        else
        {
            // 未知平台使用默认大小
            return 2048;
        }
    }

    /// <summary>
    /// 获取推荐的线程池配置
    /// </summary>
    public static void optimizethreadpool()
    {
        // 根据cpu核心数优化线程池
        int processorcount = environment.processorcount;
        
        // 设置最小工作线程数
        threadpool.setminthreads(processorcount, processorcount);
        
        // 设置最大工作线程数（避免过多线程导致上下文切换开销）
        threadpool.setmaxthreads(processorcount * 4, processorcount * 4);
    }

    /// <summary>
    /// 设置进程优先级（需要管理员权限）
    /// </summary>
    public static void sethighpriority()
    {
        try
        {
            process.getcurrentprocess().priorityclass = processpriorityclass.high;
        }
        catch (exception ex)
        {
            console.writeline($"设置进程优先级失败: {ex.message}");
        }
    }
}

/// <summary>
/// 跨平台串口通讯最佳实践指南
/// </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. 检查平台特定的串口名称格式
        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. 检查波特率是否在有效范围内
        int[] validbaudrates = { 9600, 19200, 38400, 57600, 115200, 230400, 460800, 921600 };
        if (!validbaudrates.contains(baudrate))
        {
            console.writeline($"警告: 非标准波特率 {baudrate}，可能在某些平台上不支持");
        }

        return true;
    }

    /// <summary>
    /// 获取推荐的超时设置
    /// </summary>
    /// <param name="baudrate">波特率</param>
    /// <returns>推荐的超时时间（毫秒）</returns>
    public static int getrecommendedtimeout(int baudrate)
    {
        // 根据波特率计算合理的超时时间
        // 低波特率需要更长的超时时间
        if (baudrate <= 9600)
            return 5000;
        else if (baudrate <= 57600)
            return 3000;
        else if (baudrate <= 115200)
            return 2000;
        else
            return 1000;
    }

    /// <summary>
    /// 实现重试机制
    /// </summary>
    /// <param name="operation">要执行的操作</param>
    /// <param name="maxretries">最大重试次数</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>诊断结果和建议</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. 平台特定检查
            if (platformdetector.islinux() || platformdetector.ismacos())
            {
                // 检查权限
                if (!checkunixportpermissions(portname))
                {
                    issues.add("权限不足");
                    suggestions.add($"尝试运行: sudo chmod 666 {portname}");
                    suggestions.add("或将用户添加到dialout组: sudo usermod -a -g dialout $user");
                }
            }

            // 3. 检查是否被其他程序占用
            if (isportinuse(portname))
            {
                issues.add("串口可能被其他程序占用");
                suggestions.add("关闭可能占用串口的其他程序");
                suggestions.add("使用 lsof 命令检查串口占用情况（linux/macos）");
            }

        }
        catch (exception ex)
        {
            issues.add($"诊断过程中发生错误: {ex.message}");
        }

        string result = "串口诊断结果:\n";
        result += "问题:\n" + string.join("\n", issues.select(i => $"  - {i}"));
        result += "\n建议:\n" + string.join("\n", suggestions.select(s => $"  - {s}"));

        return result;
    }

    /// <summary>
    /// 检查unix系统上的串口权限
    /// </summary>
    private static bool checkunixportpermissions(string portname)
    {
        try
        {
            var fileinfo = new fileinfo(portname);
            return fileinfo.exists; // 简化的权限检查
        }
        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>
/// 数据完整性检查器
/// 用于检测和处理数据丢失或乱码问题
/// </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>
    /// 处理接收到的数据
    /// </summary>
    /// <param name="data">接收到的原始数据</param>
    /// <returns>处理后的完整数据包</returns>
    public list<byte[]> processreceiveddata(byte[] data)
    {
        var completepackets = new list<byte[]>();

        lock (_bufferlock)
        {
            // 将新数据添加到缓冲区
            foreach (byte b in data)
            {
                _databuffer.enqueue(b);
            }

            // 尝试从缓冲区中提取完整的数据包
            while (tryextractpacket(out byte[] packet))
            {
                if (validatepacket(packet))
                {
                    completepackets.add(packet);
                }
                else
                {
                    console.writeline("检测到损坏的数据包，已丢弃");
                }
            }
        }

        return completepackets;
    }

    /// <summary>
    /// 尝试从缓冲区提取完整数据包
    /// </summary>
    private bool tryextractpacket(out byte[] packet)
    {
        packet = null;

        // 简化的数据包提取逻辑（假设固定长度的数据包）
        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>
    /// 验证数据包的完整性
    /// </summary>
    private bool validatepacket(byte[] packet)
    {
        // 实现校验和验证
        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>
/// 跨平台兼容性管理器
/// 处理不同平台间的差异和兼容性问题
/// </summary>
public static class crossplatformcompatibility
{
    /// <summary>
    /// 获取平台特定的串口配置
    /// </summary>
    /// <param name="portname">串口名称</param>
    /// <returns>平台优化的配置</returns>
    public static serialportconfig getplatformoptimizedconfig(string portname)
    {
        var config = new serialportconfig();

        if (platformdetector.iswindows())
        {
            // windows平台优化配置
            config.readbuffersize = 8192;
            config.writebuffersize = 4096;
            config.readtimeout = 1000;
            config.writetimeout = 1000;
            config.dtrenable = false;
            config.rtsenable = false;
        }
        else if (platformdetector.islinux())
        {
            // linux平台优化配置
            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平台优化配置
            config.readbuffersize = 4096;
            config.writebuffersize = 2048;
            config.readtimeout = 1500;
            config.writetimeout = 1500;
            config.dtrenable = true;
            config.rtsenable = false;
        }

        return config;
    }

    /// <summary>
    /// 平台特定的串口名称转换
    /// </summary>
    /// <param name="genericportname">通用串口名称</param>
    /// <returns>平台特定的串口名称</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;
}