C#串口热插拔检测

C# USB 热插拔有两种形式，一种是UI 界面自带的，这种不推荐，因为有可能导致界面整个死掉，第二种是调用C# 系统自带的USB 热插拔，下面献上整个代码。

下面代码由本人亲自验证，编译通过，可以直接用，如果有问题可以直接问

    using System;

    using System.IO.Ports;
    using System.Management;
    using System.Threading;


    namespace Cmc_tty_demo
    {
            /// <summary>
            /// USB控制设备类型
            /// </summary>
            public struct USBControllerDevice
            {
                /// <summary>
                /// USB控制器设备ID
                /// </summary>
                public String Antecedent;

                /// <summary>
                /// USB即插即用设备ID
                /// </summary>
                public String Dependent;
            }
            /// <summary>
            /// 监视USB插拔
            /// </summary>
            public partial class USB
            {
                /// <summary>
                /// USB插入事件监视
                /// </summary>
                private ManagementEventWatcher insertWatcher = null;

                /// <summary>
                /// USB拔出事件监视
                /// </summary>
                private ManagementEventWatcher removeWatcher = null;

                /// <summary>
                /// 添加USB事件监视器
                /// </summary>
                /// <param name="usbInsertHandler">USB插入事件处理器</param>
                /// <param name="usbRemoveHandler">USB拔出事件处理器</param>
                /// <param name="withinInterval">发送通知允许的滞后时间</param>
                public Boolean AddUSBEventWatcher(EventArrivedEventHandler usbInsertHandler, EventArrivedEventHandler usbRemoveHandler, TimeSpan withinInterval)
                {
                    try
                    {
                        ManagementScope Scope = new ManagementScope("root\\CIMV2");
                        Scope.Options.EnablePrivileges = true;

                        // USB插入监视
                        if (usbInsertHandler != null)
                        {
                            WqlEventQuery InsertQuery = new WqlEventQuery("__InstanceCreationEvent",
                                withinInterval,
                                "TargetInstance isa 'Win32_USBControllerDevice'");
                 
                        insertWatcher = new ManagementEventWatcher(Scope, InsertQuery);
                            insertWatcher.EventArrived += usbInsertHandler;
                            insertWatcher.Start();
                        }

                        // USB拔出监视
                        if (usbRemoveHandler != null)
                        {
                            WqlEventQuery RemoveQuery = new WqlEventQuery("__InstanceDeletionEvent",
                                withinInterval,
                                "TargetInstance isa 'Win32_USBControllerDevice'");
                  
                        removeWatcher = new ManagementEventWatcher(Scope, RemoveQuery);
                            removeWatcher.EventArrived += usbRemoveHandler;
                            removeWatcher.Start();
                        }

                        return true;
                    }

                    catch (Exception)
                    {
                        RemoveUSBEventWatcher();
                        return false;
                    }
                }

                /// <summary>
                /// 移去USB事件监视器
                /// </summary>
                public void RemoveUSBEventWatcher()
                {
                    if (insertWatcher != null)
                    {
                        insertWatcher.Stop();
                        insertWatcher = null;
                    }

                    if (removeWatcher != null)
                    {
                        removeWatcher.Stop();
                        removeWatcher = null;
                    }
                }

                /// <summary>
                /// 定位发生插拔的USB设备
                /// </summary>
                /// <param name="e">USB插拔事件参数</param>
                /// <returns>发生插拔现象的USB控制设备ID</returns>
                public static USBControllerDevice[] WhoUSBControllerDevice(EventArrivedEventArgs e)
                {
                    ManagementBaseObject mbo = e.NewEvent["TargetInstance"] as ManagementBaseObject;
                    if (mbo != null && mbo.ClassPath.ClassName == "Win32_USBControllerDevice")
                    {
                        String Antecedent = (mbo["Antecedent"] as String).Replace("\"", String.Empty).Split(new Char[] { '=' })[1];
                        String Dependent = (mbo["Dependent"] as String).Replace("\"", String.Empty).Split(new Char[] { '=' })[1];
                        return new USBControllerDevice[1] { new USBControllerDevice { Antecedent = Antecedent, Dependent = Dependent } };
                    }

                    return null;
                }
            }
   
        class Program
        {

            static SerialPort _serialPort;


            static USB USBWatcher= new USB();

            private static void serialPort_init( string port ) 
            {
            // Create a new SerialPort object with default settings.
            _serialPort = new SerialPort(port);

   
            // Allow the user to set the appropriate properties.
            _serialPort.BaudRate = 115200;
            _serialPort.Parity = Parity.None;
            _serialPort.DataBits = 8;
            _serialPort.StopBits = StopBits.One;
            _serialPort.Handshake = Handshake.None;
            _serialPort.RtsEnable = true;

            //初始化接收函数

            _serialPort.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            _serialPort.Open();

          
            _serialPort.Write(cmd,0,7);
        }

        static void Main(string[] args)
            {


                USBWatcher.AddUSBEventWatcher(USBEventHandler, USBEventHandler, new TimeSpan(0, 0, 1));

                while (true) ;

            }
            private static void DataReceivedHandler(
                           object sender,
                           SerialDataReceivedEventArgs e)
            {
                SerialPort sp = (SerialPort)sender;
                string indata = sp.ReadExisting();

                
                Console.WriteLine("Data Received:");

                
                Console.Write(indata);
                
            }
            private static void USBEventHandler(Object sender, EventArrivedEventArgs e)
            {
                //暂未实现
                var watcher = sender as ManagementEventWatcher;
                watcher.Stop();
                //刷新设备信息
                //RefreshDevice();
                if (e.NewEvent.ClassPath.ClassName == "__InstanceCreationEvent")
                {

                    string[] serialLst = SerialPort.GetPortNames();
                    
                    foreach (string s in serialLst) 
                    {
                        Console.WriteLine("串口："+s);
                        serialPort_init(s);
                        
                        Console.WriteLine("串口："+s+"设备打开");
                        

                    }

                Console.WriteLine("USB 设备插入 \n");
                    
                    //  m_notificationWindowApp.AddNotification((string)this.TryFindResource("USBDeviceTips"), (string)this.TryFindResource("NewUSBDevice"));
                }
                else if (e.NewEvent.ClassPath.ClassName == "__InstanceDeletionEvent")
                {


                    Console.WriteLine("USB 设备拔出 \n");
                    Console.WriteLine("关闭串口  +++++ \n");
                    //_serialPort.Close();
            
                       // _serialPort.Open()
                        
                       // _serialPort.Close();

                  
                //m_notificationWindowApp.AddNotification((string)this.TryFindResource("USBDeviceTips"), (string)this.TryFindResource("USBDeviceDisconnected"));
            }
                //Default_USBConnctionObj();
                /// Toolbar_AvailableCheck();
                // 业务代码，逻辑耗时尽量不要太长，以免影响事件的监听
                watcher.Start();
            }



        }
    }