MSDN关于SerialPort类的文章明确指出：

如果SerialPort对象在读取操作期间被阻塞，请不要中止线程。相反，关闭基本流或处理SerialPort对象。

因此，从我的角度来看，最好的方法是第二种方法，即async读取并逐步检查行尾字符。正如您所说的，对每个字符的检查都会造成很大的性能损失，我建议您研究ReadLine实现，以了解如何更快地执行此操作。请注意，它们使用SerialPort类的NewLine属性。

我还想注意的是，默认情况下没有ReadLineAsync方法，因为MSDN声明：

默认情况下，ReadLine方法将阻塞，直到收到一行如果此行为不可取，请将ReadTimeout属性设置为任何非零值，以强制ReadLine方法在端口上没有可用线路时抛出TimeoutException。

因此，在包装器中，您可以实现类似的逻辑，因此如果在某个给定时间内没有行尾，则Task将取消。此外，您应该注意：

因为SerialPort类缓冲数据BaseStream属性没有，两者可能会在如何许多字节可供读取。BytesToRead属性可以指示有字节要读取，但这些字节可能不是可访问BaseStream属性中包含的流，因为它们已经被缓冲到CCD_ 31类。

因此，我再次建议您使用异步读取来实现一些包装逻辑，并在每次读取后进行检查，是否有行结束，这应该是阻塞的，并将其包装在async方法中，这将在一段时间后取消Task。

希望这能有所帮助。

好吧，这是我所做的。。。如有意见，我们将不胜感激，因为C#对我来说还是有些新鲜！

多个线程试图同时访问串行端口(或任何资源，尤其是异步资源(，这太疯狂了。为了在不完全重写的情况下修复这个应用程序，我引入了一个锁SerialPortLockObject来保证独占串行端口访问，如下所示：

• GUI线程保持SerialPortLockObject，除非它有后台操作在运行
• SerialPort类被封装，因此不包含SerialPortLockObject的线程的任何读取或写入都会引发异常(有助于发现几个争用错误(
• 定时器类被封装(类SerialOperationTimer(，从而通过获取SerialPortLockObject来调用后台工作者函数。SerialOperationTimer一次只允许运行一个计时器(有助于发现GUI在启动不同计时器之前忘记停止后台处理的几个错误(。这可以通过使用一个特定的线程进行定时器工作来改进，该线程在定时器活动的整个时间内都保持锁(但仍将是更多的工作；因为编码的System.Timers.Timer从线程池运行工作函数(
• 当SerialOperationTimer停止时，它会禁用底层计时器并刷新串行端口缓冲区(如上面可能的方法1所述，从任何被阻止的串行端口操作中引发异常(。然后GUI线程重新获取CCD_ 42

这是SerialPort:的包装

/// <summary> CheckedSerialPort class checks that read and write operations are only performed by the thread owning the lock on the serial port </summary>
// Just check reads and writes (not basic properties, opening/closing, or buffer discards). 
public class CheckedSerialPort : SafePort /* derived in turn from SerialPort */
{
    private void checkOwnership()
    {
        try
        {
            if (Monitor.IsEntered(XXX_Conn.SerialPortLockObject)) return; // the thread running this code has the lock; all set!
            // Ooops...
            throw new Exception("Serial IO attempted without lock ownership");
        }
        catch (Exception ex)
        {
            StringBuilder sb = new StringBuilder("");
            sb.AppendFormat("Message: {0}'n", ex.Message);
            sb.AppendFormat("Exception Type: {0}'n", ex.GetType().FullName);
            sb.AppendFormat("Source: {0}'n", ex.Source);
            sb.AppendFormat("StackTrace: {0}'n", ex.StackTrace);
            sb.AppendFormat("TargetSite: {0}", ex.TargetSite);
            Console.Write(sb.ToString());
            Debug.Assert(false); // lets have a look in the debugger NOW...
            throw;
        }
    }
    public new int ReadByte()                                       { checkOwnership(); return base.ReadByte(); }
    public new string ReadTo(string value)                          { checkOwnership(); return base.ReadTo(value); }
    public new string ReadExisting()                                { checkOwnership(); return base.ReadExisting(); }
    public new void Write(string text)                              { checkOwnership(); base.Write(text); }
    public new void WriteLine(string text)                          { checkOwnership(); base.WriteLine(text); }
    public new void Write(byte[] buffer, int offset, int count)     { checkOwnership(); base.Write(buffer, offset, count); }
    public new void Write(char[] buffer, int offset, int count)     { checkOwnership(); base.Write(buffer, offset, count); }
}

这是System.Timers.Timer:的包装

/// <summary> Wrap System.Timers.Timer class to provide safer exclusive access to serial port </summary>
class SerialOperationTimer
{
    private static SerialOperationTimer runningTimer = null; // there should only be one!
    private string name;  // for diagnostics
    // Delegate TYPE for user's callback function (user callback function to make async measurements)
    public delegate void SerialOperationTimerWorkerFunc_T(object source, System.Timers.ElapsedEventArgs e);
    private SerialOperationTimerWorkerFunc_T workerFunc; // application function to call for this timer
    private System.Timers.Timer timer;
    private object workerEnteredLock = new object();
    private bool workerAlreadyEntered = false;
    public SerialOperationTimer(string _name, int msecDelay, SerialOperationTimerWorkerFunc_T func)
    {
        name = _name;
        workerFunc = func;
        timer = new System.Timers.Timer(msecDelay);
        timer.Elapsed += new System.Timers.ElapsedEventHandler(SerialOperationTimer_Tick);
    }
    private void SerialOperationTimer_Tick(object source, System.Timers.ElapsedEventArgs eventArgs)
    {
        lock (workerEnteredLock)
        {
            if (workerAlreadyEntered) return; // don't launch multiple copies of worker if timer set too fast; just ignore this tick
            workerAlreadyEntered = true;
        }
        bool lockTaken = false;
        try
        {
            // Acquire the serial lock prior calling the worker
            Monitor.TryEnter(XXX_Conn.SerialPortLockObject, ref lockTaken);
            if (!lockTaken)
                throw new System.Exception("SerialOperationTimer " + name + ": Failed to get serial lock");
            // Debug.WriteLine("SerialOperationTimer " + name + ": Got serial lock");
            workerFunc(source, eventArgs);
        }
        finally
        {
            // release serial lock
            if (lockTaken)
            {
                Monitor.Exit(XXX_Conn.SerialPortLockObject);
                // Debug.WriteLine("SerialOperationTimer " + name + ": released serial lock");
            }
            workerAlreadyEntered = false;
        }
    }
    public void Start()
    {
        Debug.Assert(Form1.GUIthreadHashcode == Thread.CurrentThread.GetHashCode()); // should ONLY be called from GUI thread
        Debug.Assert(!timer.Enabled); // successive Start or Stop calls are BAD
        Debug.WriteLine("SerialOperationTimer " + name + ": Start");
        if (runningTimer != null)
        {
            Debug.Assert(false); // Lets have a look in the debugger NOW
            throw new System.Exception("SerialOperationTimer " + name + ": Attempted 'Start' while " + runningTimer.name + " is still running");
        }
        // Start background processing
        // Release GUI thread's lock on the serial port, so background thread can grab it
        Monitor.Exit(XXX_Conn.SerialPortLockObject);
        runningTimer = this;
        timer.Enabled = true;
    }
    public void Stop()
    {
        Debug.Assert(Form1.GUIthreadHashcode == Thread.CurrentThread.GetHashCode()); // should ONLY be called from GUI thread
        Debug.Assert(timer.Enabled); // successive Start or Stop calls are BAD
        Debug.WriteLine("SerialOperationTimer " + name + ": Stop");
        if (runningTimer != this)
        {
            Debug.Assert(false); // Lets have a look in the debugger NOW
            throw new System.Exception("SerialOperationTimer " + name + ": Attempted 'Stop' while not running");
        }
        // Stop further background processing from being initiated,
        timer.Enabled = false; // but, background processing may still be in progress from the last timer tick...
        runningTimer = null;
        // Purge serial input and output buffers. Clearing input buf causes any blocking read in progress in background thread to throw
        //   System.IO.IOException "The I/O operation has been aborted because of either a thread exit or an application request.'r'n"
        if(Form1.xxConnection.PortIsOpen) Form1.xxConnection.CiCommDiscardBothBuffers();
        bool lockTaken = false;
        // Now, GUI thread needs the lock back.
        // 3 sec REALLY should be enough time for background thread to cleanup and release the lock:
        Monitor.TryEnter(XXX_Conn.SerialPortLockObject, 3000, ref lockTaken);
        if (!lockTaken)
            throw new Exception("Serial port lock not yet released by background timer thread "+name);
        if (Form1.xxConnection.PortIsOpen)
        {
            // Its possible there's still stuff in transit from device (for example, background thread just completed
            // sending an ACQ command as it was stopped). So, sync up with the device...
            int r = Form1.xxConnection.CiSync();
            Debug.Assert(r == XXX_Conn.CI_OK);
            if (r != XXX_Conn.CI_OK)
                throw new Exception("Cannot re-sync with device after disabling timer thread " + name);
        }
    }
    /// <summary> SerialOperationTimer.StopAllBackgroundTimers() - Stop all background activity </summary>
    public static void StopAllBackgroundTimers()
    {
        if (runningTimer != null) runningTimer.Stop();
    }
    public double Interval
    {
        get { return timer.Interval; }
        set { timer.Interval = value; }
    }
} // class SerialOperationTimer