// 核心架構(gòu)：異步隊列 + 批量處理
private readonly ConcurrentQueue<byte> dataQueue = new ConcurrentQueue<byte>();
private readonly CancellationTokenSource cancellation = new CancellationTokenSource();
private Task processingTask;

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
namespaceAppHighPerformanceSerialPort
{
    publicclassHighPerformanceReceiver : IDisposable
    {
        private SerialPort serialPort;
        privatereadonly ConcurrentQueue<byte> dataQueue = new ConcurrentQueue<byte>();
        privatereadonly CancellationTokenSource cancellation = new CancellationTokenSource();
        private Task processingTask;
        privatebool disposed = false;
        
        publicevent Action<byte[]> PacketReceived;
        
        publicint ProcessingIntervalMs { get; set; } = 5;
        publicint SilenceThresholdMs { get; set; } = 50;
        publicint MaxBufferSize { get; set; } = 4096;
        
        public HighPerformanceReceiver(string portName, int baudRate)
        {
            InitializeSerialPort(portName, baudRate);
            processingTask = Task.Run(ProcessDataAsync, cancellation.Token);
        }
        
        private void InitializeSerialPort(string portName, int baudRate)
        {
            serialPort = new SerialPort(portName, baudRate, Parity.None, 8, StopBits.One)
            {
                ReadTimeout = 1000,
                WriteTimeout = 1000
            };
            serialPort.DataReceived += OnDataReceived;
            serialPort.Open();
        }
        
        private void OnDataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            if (disposed || cancellation.Token.IsCancellationRequested)
                return;
            
            try
            {
                while (serialPort?.IsOpen == true && serialPort.BytesToRead > 0)
                {
                    int data = serialPort.ReadByte();
                    if (data != -1)
                    {
                        dataQueue.Enqueue((byte)data);
                    }
                }
            }
            catch (Exception ex)
            {
                if (!disposed)
                {
                    Console.WriteLine($"數(shù)據(jù)接收異常：{ex.Message}");
                }
            }
        }
        
        private async Task ProcessDataAsync()
        {
            var buffer = new List<byte>();
            var lastDataTime = DateTime.MinValue;
            
            try
            {
                while (!cancellation.Token.IsCancellationRequested)
                {
                    bool hasData = false;
                    DateTime currentTime = DateTime.Now;
                    
                    // 批量處理隊列中的數(shù)據(jù)
                    while (dataQueue.TryDequeue(outbyte data))
                    {
                        buffer.Add(data);
                        lastDataTime = currentTime;
                        hasData = true;
                        
                        if (buffer.Count >= MaxBufferSize)
                        {
                            await EmitPacket(buffer.ToArray());
                            buffer.Clear();
                            break;
                        }
                    }
                    
                    // 檢查靜默超時
                    if (!hasData && buffer.Count > 0 && lastDataTime != DateTime.MinValue)
                    {
                        double silenceDuration = (currentTime - lastDataTime).TotalMilliseconds;
                        if (silenceDuration >= SilenceThresholdMs)
                        {
                            await EmitPacket(buffer.ToArray());
                            buffer.Clear();
                            lastDataTime = DateTime.MinValue;
                        }
                    }
                    
                    await Task.Delay(ProcessingIntervalMs, cancellation.Token);
                }
            }
            catch (OperationCanceledException)
            {
            }
            catch (Exception ex)
            {
                if (!disposed)
                {
                    Console.WriteLine($"數(shù)據(jù)處理異常：{ex.Message}");
                }
            }
            finally
            {
                // 處理剩余數(shù)據(jù)
                if (buffer.Count > 0)
                {
                    try
                    {
                        await EmitPacket(buffer.ToArray());
                    }
                    catch
                    {
                    }
                }
            }
        }
        
        private async Task EmitPacket(byte[] packet)
        {
            if (packet.Length > 0 && !disposed)
            {
                try
                {
                    await Task.Run(() => PacketReceived?.Invoke(packet));
                }
                catch
                {
                }
            }
        }
        
        public void Dispose()
        {
            if (disposed)
                return;
            
            disposed = true;
            
            try
            {
                // 取消處理任務(wù)
                cancellation.Cancel();
                
                // 先關(guān)閉串口，停止數(shù)據(jù)接收
                if (serialPort?.IsOpen == true)
                {
                    serialPort.Close();
                }
                
                // 等待處理任務(wù)完成，但不阻塞太久
                if (processingTask != null && !processingTask.IsCompleted)
                {
                    if (!processingTask.Wait(500))
                    {
                        Console.WriteLine("處理任務(wù)未能及時完成，強制退出");
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Dispose 異常：{ex.Message}");
            }
            finally
            {
                try
                {
                    serialPort?.Dispose();
                    cancellation?.Dispose();
                }
                catch
                {
                }
            }
        }
    }
}

// 傳統(tǒng)方式：每字節(jié)觸發(fā)一次事件
serialPort.DataReceived += (s, e) => {
    int data = serialPort.ReadByte();
    ProcessSingleByte((byte)data);
};
 
// 高效方式：批量處理
while (serialPort.BytesToRead > 0)
{
    dataQueue.Enqueue((byte)serialPort.ReadByte());
}

// 關(guān)鍵技巧：預(yù)分配容器大小
var buffer = new List<byte>(MaxBufferSize);
 
// 定期清理 UI 文本，防止內(nèi)存泄漏
if (rtbData.TextLength > 100000)
    rtbData.Text = rtbData.Text.Substring(50000);

// 使用 ConcurrentQueue 確保線程安全
private readonly ConcurrentQueue<byte> dataQueue = new ConcurrentQueue<byte>();
 
// 正確的 UI 線程調(diào)用方式
if (InvokeRequired)
{
    try
    {
        Invoke(new Action<byte[]>(OnPacketReceived), packet);
    }
    catch { return; }
}