10

我有一个 C# windows 窗体应用程序,它通过 COM 端口与 USB 加密狗进行通信。我正在使用 .Net 2.0 中的 SerialPort 类进行通信,并且串行端口对象在应用程序的整个生命周期内都是开放的。应用程序向设备发送命令,也可以从设备接收未经请求的数据。

关闭表单时会出现我的问题 - 尝试关闭 COM 端口时,我得到(随机,不幸)ObjectDisposedException。这是 Windows 堆栈跟踪:

System.ObjectDisposedException was unhandled


Message=Safe handle has been closed
  Source=System
  ObjectName=""
  StackTrace:
       at Microsoft.Win32.UnsafeNativeMethods.SetCommMask(SafeFileHandle hFile, Int32 dwEvtMask)
       at System.IO.Ports.SerialStream.Dispose(Boolean disposing)
       at System.IO.Ports.SerialStream.Finalize()
  InnerException: 

我从有类似问题的人那里找到了帖子,并尝试了解决方法 [这里][1]

[1]:http: //zachsaw.blogspot.com/2010/07/net-serialport-woes.html虽然这是针对 IOException 并没有阻止问题。

我的 Close() 代码如下:

        public void Close()
    {
        try
        {
            Console.WriteLine("******ComPort.Close - baseStream.Close*******");
            baseStream.Close();
        }
        catch (Exception ex)
        {
            Console.WriteLine("******ComPort.Close baseStream.Close raised exception: " + ex + "*******");
        }
        try
        {
            _onDataReceived = null;
            Console.WriteLine("******ComPort.Close - _serialPort.Close*******");
            _serialPort.Close();
        }
        catch (Exception ex)
        {
            Console.WriteLine("******ComPort.Close - _serialPort.Close raised exception: " + ex + "*******");
        }            
    }

我的日志显示执行永远不会超出尝试关闭 SerialPort 的 BaseStream(这是在第一个try块中),所以我尝试删除这一行,但仍然定期抛出异常 - 第二个try块中的日志记录出现然后异常发生。两个 catch 块都没有捕获异常。

有任何想法吗?

更新 - 添加完整课程:

    namespace My.Utilities
{
    public interface ISerialPortObserver
    {
        void SerialPortWriteException();
    }

    internal class ComPort : ISerialPort
    {
        private readonly ISerialPortObserver _observer;
        readonly SerialPort _serialPort;

        private DataReceivedDelegate _onDataReceived;
        public event DataReceivedDelegate OnDataReceived
        {
            add { lock (_dataReceivedLocker) { _onDataReceived += value; } }
            remove { lock (_dataReceivedLocker) { _onDataReceived -= value; } }            
        }

        private readonly object _dataReceivedLocker = new object();
        private readonly object _locker = new object();

        internal ComPort()
        {         
            _serialPort = new SerialPort { ReadTimeout = 10, WriteTimeout = 100, DtrEnable = true };
            _serialPort.DataReceived += DataReceived;
        }

        internal ComPort(ISerialPortObserver observer) : this()
        {
            _observer = observer;         
        }

        private void DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            DataReceivedDelegate temp = null;

            lock (_locker)
            {
                lock (_dataReceivedLocker)
                {
                    temp = _onDataReceived;
                }

                string dataReceived = string.Empty;
                var sp = (SerialPort) sender;

                try
                {
                    dataReceived = sp.ReadExisting();
                }
                catch (Exception ex)
                {
                    Logger.Log(TraceLevel.Error, "ComPort.DataReceived raised exception: " + ex);
                }

                if (null != temp && string.Empty != dataReceived)
                {
                    try
                    {
                        temp(dataReceived, TickProvider.GetTickCount());
                    }
                    catch (Exception ex)
                    {
                        Logger.Log(TraceLevel.Error, "ComPort.DataReceived raised exception calling handler: " + ex);
                    }
                }
            }
        }

        public string Port
        {
            set
            {
                try
                {
                    _serialPort.PortName = value;
                }
                catch (Exception ex)
                {
                    Logger.Log(TraceLevel.Error, "ComPort.Port raised exception: " + ex);
                }
            }
        }

        private System.IO.Stream comPortStream = null;
        public bool Open()
        {
            SetupSerialPortWithWorkaround();
            try
            {
                _serialPort.Open();
                comPortStream = _serialPort.BaseStream;
                return true;
            }
            catch (Exception ex)
            {
                Logger.Log(TraceLevel.Warning, "ComPort.Open raised exception: " + ex);
                return false;
            }
        }

        public bool IsOpen
        {
            get
            {
                SetupSerialPortWithWorkaround();
                try
                {
                    return _serialPort.IsOpen;
                }
                catch(Exception ex)
                {
                    Logger.Log(TraceLevel.Error, "ComPort.IsOpen raised exception: " + ex);
                }

                return false;
            }
        }

        internal virtual void SetupSerialPortWithWorkaround()
        {
            try
            {
                //http://zachsaw.blogspot.com/2010/07/net-serialport-woes.html
                // This class is meant to fix the problem in .Net that is causing the ObjectDisposedException.
                SerialPortFixer.Execute(_serialPort.PortName);
            }
            catch (Exception e)
            {
                Logger.Log(TraceLevel.Info, "Work around for .Net SerialPort object disposed exception failed with : " + e + " Will still attempt open port as normal");
            }
        }

        public void Close()
        {
            try
            {
                comPortStream.Close();
            }
            catch (Exception ex)
            {
                Logger.Log(TraceLevel.Error, "ComPortStream.Close raised exception: " + ex);
            }
            try
            {
                _onDataReceived = null;
                _serialPort.Close();
            }
            catch (Exception ex)
            {
                Logger.Log(TraceLevel.Error, "ComPort.Close raised exception: " + ex);
            }            
        }

        public void WriteData(string aData, DataReceivedDelegate handler)
        {
            try
            {
                OnDataReceived += handler;
                _serialPort.Write(aData + "\r\n");
            }
            catch (Exception ex)
            {
                Logger.Log(TraceLevel.Error, "ComPort.WriteData raised exception: " + ex);                

                if (null != _observer)
                {
                    _observer.SerialPortWriteException();
                }
            }
        }
    }    
}
4

3 回答 3

31

注意:目前的发现仅在 Windows 7 上的 .NET Framework 4.0 32 位上进行了测试,如果它适用于其他版本,请随时发表评论。

编辑: TL;DR:这是解决方法的症结所在。请参阅下面的说明。在打开 SerialPort 时也不要忘记使用SerialPortFixer 。ILog 来自 log4net。

static readonly ILog s_Log = LogManager.GetType("SerialWorkaroundLogger");

static void SafeDisconnect(SerialPort port, Stream internalSerialStream)
{
    GC.SuppressFinalize(port);
    GC.SuppressFinalize(internalSerialStream);

    ShutdownEventLoopHandler(internalSerialStream);

    try
    {
        s_Log.DebugFormat("Disposing internal serial stream");
        internalSerialStream.Close();
    }
    catch (Exception ex)
    {
        s_Log.DebugFormat(
            "Exception in serial stream shutdown of port {0}: {1}", port.PortName, ex);
    }

    try
    {
        s_Log.DebugFormat("Disposing serial port");
        port.Close();
    }
    catch (Exception ex)
    {
        s_Log.DebugFormat("Exception in port {0} shutdown: {1}", port.PortName, ex);
    }
}

static void ShutdownEventLoopHandler(Stream internalSerialStream)
{
    try
    {
        s_Log.DebugFormat("Working around .NET SerialPort class Dispose bug");

        FieldInfo eventRunnerField = internalSerialStream.GetType()
            .GetField("eventRunner", BindingFlags.NonPublic | BindingFlags.Instance);

        if (eventRunnerField == null)
        {
            s_Log.WarnFormat(
                "Unable to find EventLoopRunner field. "
                + "SerialPort workaround failure. Application may crash after "
                + "disposing SerialPort unless .NET 1.1 unhandled exception "
                + "policy is enabled from the application's config file.");
        }
        else
        {
            object eventRunner = eventRunnerField.GetValue(internalSerialStream);
            Type eventRunnerType = eventRunner.GetType();

            FieldInfo endEventLoopFieldInfo = eventRunnerType.GetField(
                "endEventLoop", BindingFlags.Instance | BindingFlags.NonPublic);

            FieldInfo eventLoopEndedSignalFieldInfo = eventRunnerType.GetField(
                "eventLoopEndedSignal", BindingFlags.Instance | BindingFlags.NonPublic);

            FieldInfo waitCommEventWaitHandleFieldInfo = eventRunnerType.GetField(
                "waitCommEventWaitHandle", BindingFlags.Instance | BindingFlags.NonPublic);

            if (endEventLoopFieldInfo == null
                || eventLoopEndedSignalFieldInfo == null
                || waitCommEventWaitHandleFieldInfo == null)
            {
                s_Log.WarnFormat(
                    "Unable to find the EventLoopRunner internal wait handle or loop signal fields. "
                    + "SerialPort workaround failure. Application may crash after "
                    + "disposing SerialPort unless .NET 1.1 unhandled exception "
                    + "policy is enabled from the application's config file.");
            }
            else
            {
                s_Log.DebugFormat(
                    "Waiting for the SerialPort internal EventLoopRunner thread to finish...");

                var eventLoopEndedWaitHandle =
                    (WaitHandle)eventLoopEndedSignalFieldInfo.GetValue(eventRunner);
                var waitCommEventWaitHandle =
                    (ManualResetEvent)waitCommEventWaitHandleFieldInfo.GetValue(eventRunner);

                endEventLoopFieldInfo.SetValue(eventRunner, true);

                // Sometimes the event loop handler resets the wait handle
                // before exiting the loop and hangs (in case of USB disconnect)
                // In case it takes too long, brute-force it out of its wait by
                // setting the handle again.
                do
                {
                    waitCommEventWaitHandle.Set();
                } while (!eventLoopEndedWaitHandle.WaitOne(2000));

                s_Log.DebugFormat("Wait completed. Now it is safe to continue disposal.");
            }
        }
    }
    catch (Exception ex)
    {
        s_Log.ErrorFormat(
            "SerialPort workaround failure. Application may crash after "
            + "disposing SerialPort unless .NET 1.1 unhandled exception "
            + "policy is enabled from the application's config file: {0}",
            ex);
    }
}

在最近的一个项目中,我已经为此苦苦挣扎了几天。

.NET SerialPort 类有许多不同的错误(到目前为止我已经看到),这些错误会导致 Web 上的所有问题。

  1. 此处缺少的 DCB 结构标志:http: //zachsaw.blogspot.com/2010/07/net-serialport-woes.html 这个是由 SerialPortFixer 类修复的,这个归功于作者。

  2. 移除 USB 串口设备时,关闭 SerialPortStream 时,要求 eventLoopRunner 停止,SerialPort.IsOpen 返回 false。处置时检查此属性并跳过关闭内部串行流,从而无限期地保持原始句柄打开(直到终结器运行导致下一个问题)。

    这个解决方案是手动关闭内部串行流。我们可以在异常发生之前通过 SerialPort.BaseStream 获取它的引用,或者通过反射并获取“internalSerialStream”字段。

  3. 当 USB 串行设备被移除时,关闭内部串行流会引发异常并关闭内部句柄而不等待其 eventLoopRunner 线程完成,从而导致稍后在流的终结器运行时来自后台事件循环运行器线程的无法捕获的 ObjectDisposedException(奇怪地避免抛出异常,但仍然无法等待 eventLoopRunner)。

    这里的症状:https ://connect.microsoft.com/VisualStudio/feedback/details/140018/serialport-crashes-after-disconnect-of-usb-com-port

    解决方案是手动要求事件循环运行器停止(通过反射)并等待它完成,然后再关闭内部串行流。

  4. 由于 Dispose 会引发异常,因此不会抑制终结器。这很容易解决:

    GC.SuppressFinalize(端口); GC.SuppressFinalize(port.BaseStream);

这是一个包装串行端口并修复所有这些问题的类:http: //pastebin.com/KmKEVzR8

有了这个解决方法类,恢复到 .NET 1.1 未处理的异常行为是不必要的,并且它具有出色的稳定性。

这是我的第一个贡献,所以如果我做得不对,请原谅。我希望它可以帮助某人。

于 2012-01-29T21:58:11.627 回答
12

是的,SerialPort 类中存在使这种崩溃成为可能的缺陷。当您调用 Open() 时,SerialPort 会启动一个线程。该线程监视端口上的事件,例如,这就是您获取 DataReceived 事件的方式。当您调用 BaseStream.Close() 或 Close() 或 Dispose() 方法(它们都做同样的事情)时,SerialPort 只要求线程退出但不等待它退出。

这会导致各种问题。一个记录了一个,你不应该在关闭它后立即 Open() 一个端口。但是这里的不幸是当你的程序在 Close() 调用之后立即退出或垃圾收集。这会运行终结器,并且它也会尝试关闭句柄。它仍然是打开的,因为工作线程仍在使用它。现在可以进行线程竞赛,但这没有正确联锁。当工作线程在终结器线程尝试执行相同操作之前设法关闭句柄并退出时,就会发生 kaboom。异常是无法捕获的,因为它发生在终结器线程中,CLR 中止程序。

自 2.0 以来的每个 .NET 版本都在类中进行了小的更改,以解决 SerialPort 问题。到目前为止,如果您仍在使用 .NET 2.0,最好的办法是不要实际调用 Close()。无论如何,它会自动发生,终结器会处理它。即使由于某种原因(硬崩溃或程序中止)没有发生这种情况,Windows 也会确保端口已关闭。

于 2012-01-19T17:26:21.487 回答
7

我知道这是一个相当古老但又很流行的问题。根据发行说明,我最近遇到了这个问题,在寻找解决方案之后,看起来这个问题终于用 .NET Framework 4.7 解决了。 https://github.com/Microsoft/dotnet/blob/master/releases/net47/dotnet47-changes.md

修复了 SerialPort 中在执行期间拔出设备可能导致 SerialStream 类中的内存泄漏的问题。[288363]

于 2017-09-27T07:32:39.607 回答