C＃如何检查USB端口与USB集线器和使用的控制器？ [英] C# How do I check USB Ports with USB Hub and used Controller?

查看：2339
本文介绍了C＃如何检查USB端口与USB集线器和使用的控制器？的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

我目前正在尝试使用其USB集线器扫描所有USB端口（检查它是否为Root）以及它们连接到的控制器。



它更可见：

  USB Port1（没有插入） - > USB Hub1 | |  - >控制器1 
 USB端口2（键盘已插入） - > |  - > USB根集线器|  - >控制器2 
 USB端口3（未插入） - > USB Hub2 | | 
 USB Port4（没有插入） - > |  - > USB根集线器|  - > Controller3（Mainboard）

我想将用户所有端口和连接的集线器显示为树。如果USB端口及其控制器正在使用中。



我希望你们能理解我想要描述的内容。如果你能给我一些关键字，甚至代码片段，我会非常感激它。



PS：对不起我的英语。



这是到目前为止的代码（我使用的.NetFramework 4.5.x）：



USBPortScanner类： em> 

  
 using System.Collections.Generic; 
 using System.Linq; 
 using System.Text; 
 using System.Threading.Tasks; 
使用System.Management; 
 using System.IO.Ports; 
 
 namespace USBPortScanner 
 
 {
 class USBPortScanner 
 {
 static void Main（string [] args）
 {
 var usbDevices = GetUSBDevices（）; 
 foreach（var usbDevice in usbDevices）
 {
 //打印所有已定义的属性，它们需要在USBDeviceInfo.cs中定义！ 
 Console.WriteLine（Name：{0} \r\\\
Caption：{1} \r\\\
Error代码：{2} \r\\\
Device ID：{3} \r\\ \\ nSystem Name：{4} \r\\\
Status：{5}，
 usbDevice.Name，usbDevice.Caption，usbDevice.ConfigManagerErrorCode，usbDevice.DeviceID，usbDevice.SystemName，usbDevice.Status）; 
 Console.WriteLine（）; 
} 
 
 Console.Read（）; 
} 
 //设置设备变量的属性
 static List< USBDeviceInfo> GetUSBDevices（）
 {
 List< USBDeviceInfo> devices = new List< USBDeviceInfo>（）; 
 
 //使用（VARCHARCHER = new ManagementObjectSearcher（@Select * From Win32_USBHub））使用WMI 
扫描所有USBHubs 
 {
 using（ManagementObjectCollection collection = searcher.Get（））
 {
 foreach（集合中的ManagementObject设备）
 {
 
 //显示所有可用数据
 //控制台。 WriteLine（device.Path）; 
 
 // foreach（device.Properties中的PropertyData prop）
 // {
 // Console.WriteLine（prop.Name +：+ prop.Value）; 
 //} 
 
 //Console.WriteLine（）; 
 
 //将属性添加到设备
 devices.Add（new USBDeviceInfo（device））; 
} 
} 
} 
 
返回设备; 
} 
} 
}

USBDeviceInfo类： 

  
 using System.Collections.Generic; 
 using System.Linq; 
 using System.Text; 
 using System.Threading.Tasks; 
使用System.Management; 
 
 namespace USBPortScanner 
 {
 
 class USBDeviceInfo 
 {
 public USBDeviceInfo（ManagementObject device）
 {
 .Name = device.GetPropertyValue（Name）。ToString（）; 
 this.Caption = device.GetPropertyValue（Caption）。ToString（）; 
 
 if（device.GetPropertyValue（ConfigManagerErrorCode）！= null）
 {
 this.ConfigManagerErrorCode =（ErrorCode）device.GetPropertyValue（ConfigManagerErrorCode）; 
} 
 else 
 {
 this.ConfigManagerErrorCode = ErrorCode.Device_is_not_present_not_working_properly_or_does_not_have_all_of_its_drivers_installed; 
} 
 
 this.DeviceID = device.GetPropertyValue（DeviceID）。ToString（）; 
 this.SystemName = device.GetPropertyValue（SystemName）。ToString（）; 
 this.Status = device.GetPropertyValue（Status）。ToString（）; 
} 
 
 //在Program.cs中设置上面可用于我们的目的的变量
 public string Name {get;私人集} 
 public string Caption {get;私人集} 
 public ErrorCode ConfigManagerErrorCode {get;私人集} 
 public string DeviceID {get;私人集} 
 public string SystemName {get;私人集} 
 public string Status {get;私人集} 
} 
枚举错误码：UINT 
 {
 Device_is_working_properly = 0，
 Device_is_not_configured_correctly = 1，
 Windows_cannot_load_the_driver_for_this_device = 2，
 Driver_for_this_device_might_be_corrupted_or_the_system_may_be_low_on_memory_or_other_resources = 3 ，
 Device_is_not_working_properly_One_of_its_drivers_or_the_registry_might_be_corrupted = 4，
 Driver_for_the_device_requires_a_resource_that_Windows_cannot_manage = 5，
 Boot_configuration_for_the_device_conflicts_with_other_devices = 6，
 Cannot_filter = 7，
 Driver_loader_for_the_device_is_missing = 8，
 Device_is_not_working_properly_The_controlling_firmware_is_incorrectly_reporting_the_resources_for_the_device = 9，$ $ b Device_cannot_start = 10，
 b Windows_cannot_identify_all_of_the_resources_that_the_device_uses = 16，
 Device_is_requesting_an_unknown_resource_type = 17，
 Device_drivers_must_be_reinstalled = 18，
 Failure_using_the_VxD_loader = 19，
 Registry_might_be_corrupted = 20，
 System_failure_If_changing_the_device_driver_is_ineffective_see_the_hardware_documentation_Windows_is_removing_the_device = 21，
 Device_is_disabled = 22，
 System_failure_If_changing_the_device_driver_is_ineffective_see_the_hardware_documentation = 23，
 Device_is_not_present_not_working_properly_or_does_not_have_all_of_its_drivers_installed = 24，
 Windows_is_still_setting_up_the_device = 25 | 26，
 Device_does_not_have_valid_log_configuration = 27，
 Device_drivers_are_not_installed = 28，
 Device_is_disabled_The_device_firmware_did_not_provide_the_required_resources = 29，
 Device_is_using_an_IRQ_resource_that_another_device_is_using = 30，
 Device_is_not_working_properly_Windows_cannot_load_the_required_device_drivers = 31，
 
 } 
}


解决方案

解决方案。下面的代码是我从另一个网站使用的示例。我希望它也会帮助社区。

来源： http://www.news2news.com/vfp/?example=545&ver=vcs&PHPSESSID=70ba6845606a96b355ab7f772fb14386



代码：

 使用System; 
 using System.Collections.Generic; 
 using System.Runtime.InteropServices; 
 using System.Linq; 
 
命名空间DeviceEnumerator 
 {
 public class Program 
 {
 public static void Main（）
 {
 var deviceTree = new DeviceTree（）; 
 
 foreach（Win32.DeviceClasses中的var deviceClass）
 {
 Console.WriteLine（\\\
 {0}：，deviceClass.Value）; 
 
的foreach（在deviceTree.DeviceNodes $ B $ VAR设备b。凡（D => d.ClassGuid == deviceClass.Key））
 {
 Console.WriteLine（ 
\t {1}：{0}，
 device.Description，
 device.EnumeratorName）; 
} 
} 
 
 Console.Write（\\\
\\\
Any key ...）; 
 Console.ReadKey（）; 
} 
} 
 
 public class DeviceTree：IDisposable 
 {
 private IntPtr _machineHandle = IntPtr.Zero; 
 private IntPtr _rootDeviceHandle = IntPtr.Zero; 
 private DeviceNode _rootNode; 
 
 //找到所有设备的平面集合
 private List< DeviceNode> _deviceNodes; 
 
 public DeviceNode根节点
 {
 get 
 {
 return this._rootNode; 
} 
} 
 
 public List< DeviceNode> DeviceNodes 
 {
 get 
 {
 return this._deviceNodes; 
} 
} 
 
 public DeviceTree（）
 {
 EnumerateDevices（）; 
} 
 
〜DeviceTree（）
 {
 this.Dispose（false）; 
} bb 
 $ b public void Dispose（）
 {
 this.Dispose（true）; 
 GC.SuppressFinalize（this）; 
} 
 
 protected virtual void Dispose（bool disposal）
 {
 if（处置）
 {
 this._deviceNodes.Clear ; 
} 
 
 this.DisconnectFromMachine（）; 
} 
 
 private void EnumerateDevices（）
 {
 this.DisconnectFromMachine（）; 
 
 //本地机器假定
 if（Win32.CM_Connect_Machine（
 null，ref this._machineHandle）！= 0）
 {
 return; 
} 
 
试
 {
 Win32.CM_Locate_DevNode_Ex（
裁判this._rootDeviceHandle，
 0，
 0，
 this._machineHandle）; 
 
 //递归枚举
 this._rootNode =新DeviceNode（
 this._rootDeviceHandle，
空，
 this._machineHandle）; 
} 
 finally 
 {
 this.DisconnectFromMachine（）; 
 
 if（this._rootNode！= null）
 {
 this._deviceNodes = this._rootNode 
 .Flatten（node => node.Children）.ToList （）; 
} 
} 
} 
 
 private void DisconnectFromMachine（）
 {
 if（this._machineHandle！= IntPtr.Zero）
 {
 Win32.CM_Disconnect_Machine（this._machineHandle）; 
 this._machineHandle = IntPtr.Zero; 
} 
} 
} 
 
 public class DeviceNode：IDisposable 
 {
 private readonly DeviceNode _parentDevice; 
 private readonly List< DeviceNode> _children; 
 private readonly IntPtr _deviceHandle; 
 private readonly IntPtr _machineHandle; 
 
私人readonly字典< int，string> 
 _deviceProperties; 
 
 public DeviceNode ParentDevice 
 {
 get 
 {
 return _parentDevice; 
} 
} 
 
公共字典< int，string> DeviceProperties 
 {
 get 
 {
 return _deviceProperties; 
} 
} 
 
 public List< DeviceNode>孩子
 {
 get 
 {
 return this._children; 
} 
} 
 
 public Guid ClassGuid 
 {
 get 
 {
 string buffer = 
 this.GetProperty （Win32.DevRegProperty.ClassGuid）; 
 
 var guid = new Guid（）; 
 
 if（buffer.Length> = 32）
 {
 try 
 {
 guid = new Guid（buffer）; 
} 
 catch 
 {
 guid = new Guid（）; 
} 
} 
 
 return guid; 
} 
} 
 
 public string描述
 {
 get 
 {
 return 
 GetProperty（Win32.DevRegProperty .DeviceDescription）; 
} 
} 
 
 public string FriendlyName 
 {
 get 
 {
 return 
 GetProperty（Win32.DevRegProperty .FriendlyName）; 
} 
} 
 
 public string EnumeratorName 
 {
 get 
 {
 return 
 GetProperty（Win32.DevRegProperty .EnumeratorName）; 
} 
} 
 
 public string LocationInfo 
 {
 get 
 {
 return 
 GetProperty（Win32.DevRegProperty .LocationInfo）; 
} 
} 
 
 public DeviceNode（IntPtr deviceHandle，DeviceNode parentDevice）
：this（
 deviceHandle，
 parentDevice，
 parentDevice._machineHandle）
 {
} 
 
 public DeviceNode（
 IntPtr deviceHandle，
 DeviceNode parentDevice，
 IntPtr machineHandle）
 {
 _deviceProperties = new Dictionary< int，string>（）; 
 _children = new List< DeviceNode>（）; 
 
 _deviceHandle = deviceHandle; 
 _machineHandle = machineHandle; 
 _parentDevice = parentDevice; 
 
 EnumerateDeviceProperties（）; 
 EnumerateChildren（）; 
} 
 
私有字符串GetProperty（
 Win32.DevRegProperty devRegProperty）
 {
 return GetProperty（（int）devRegProperty）; 
} 
 
私有字符串GetProperty（int index）
 {
 string buffer; 
 var result = this._deviceProperties 
 .TryGetValue（index，out buffer）; 
返回结果？ buffer：string.Empty; 
} 
 
 private void EnumerateDeviceProperties（）
 {
 for（var index = 0; index< 64; index ++）
 {
 uint bufsize = 2048; 
 
 IntPtr buffer = 
 Marshal.AllocHGlobal（（int）bufsize）; 
 
 var result = 
 Win32.CM_Get_DevNode_Registry_Property_Ex（
 _deviceHandle，
 index，
 IntPtr.Zero，
 buffer，
 ref bufsize，
 0，
 _machineHandle）; 
 
 var propertyString = result == 0 
？ Marshal.PtrToStringAnsi（buffer）
：string.Empty; 
 
 _deviceProperties.Add（index，propertyString）; 
 
 Marshal.FreeHGlobal（buffer）; 
} 
} 
 
 private void EnumerateChildren（）
 {
 IntPtr ptrFirstChild = IntPtr.Zero; 
 
 if（Win32.CM_Get_Child_Ex（
 ref ptrFirstChild，
 _deviceHandle，
 0，
 _machineHandle）！= 0）
 {
 return; 
} 
 
 var ptrChild = ptrFirstChild; 
 var ptrSibling = IntPtr.Zero; 
 
 do 
 {
 var childDevice = new DeviceNode（ptrChild，this）; 
 _children.Add（childDevice）; 
 
 if（Win32.CM_Get_Sibling_Ex（
 ref ptrSibling，
 ptrChild，
 0，
 _machineHandle）！= 0）break; 
 
 ptrChild = ptrSibling; 
} 
 while（true）; 
} bb 
 $ b public void Dispose（）
 {
 this.Dispose（true）; 
 GC.SuppressFinalize（this）; 
} 
 
 protected virtual void Dispose（bool disposal）
 {
 if（disposal）
 {
 _deviceProperties.Clear 
} 
} 
} 
 
内部静态类LinqExtensionMethods 
 {
 public static IEnumerable< T>返回& T>（T element）
 {
 yield return element; 
} 
 
 public static IEnumerable< T> StartWith< T>（
 this IEnumerable< T> list，T element）
 {
 return Return（element）.Concat（list）; 
} 
 
 public static IEnumerable< TEntity> Flatten< TEntity>（
 this TEntity element，
 Func< TEntity，IEnumerable< TEntity>> childSelector）
 {
 if（childSelector（element）！= null）
 return childSelector（element）
 .SelectMany（child => child.Flatten（childSelector））
 .StartWith（element）; 
 
 var items = new List< TEntity> {element}; 
 return item; 
} 
} 
 
 public static class Win32 
 {
 //这是部分列表
 public static readonly 
字典< ; Guid，string> DeviceClasses = 
 new Dictionary< Guid，string> 
 {
 {new Guid（{4d36e967-e325-11ce-bfc1-08002be10318}），
磁盘驱动器}，
 {new Guid（{4d36e968- e325-11ce-bfc1-08002be10318}），
显示适配器}，
 {new Guid（{4d36e96b-e325-11ce-bfc1-08002be10318}），
 }，
 {new Guid（{4d36e96f-e325-11ce-bfc1-08002be10318}），
Mice}，
}; 
 
 public enum DevRegProperty：uint 
 {
 DeviceDescription = 1，
 HardwareId = 2，
 CompatibleIds = 3，
 Unused0 = 
 Service = 5，
 Unused1 = 6，
 Unused2 = 7，
 Class = 8，
 ClassGuid = 9，
 Driver = 0x0a，
 ConfigFlags = 0x0b，
 Mfg = 0x0c，
 FriendlyName = 0x0d，
 LocationInfo = 0x0e，
 PhysicalDeviceObjectName = 0x0f，
 Capabilities = 0x10，
 UNNumber = 0x11，
 UpperFilters = 0x12，
 LowerFilters = 0x13，
 BusTypeGuid = 0x014，
 LegacyBusType = 0x15，
 BusNumber = 0x16，
 EnumeratorName = 0xb，
} 
 
 [DllImport（kernel32.dll）] 
 public static extern uint GetLogicalDrives（）; 
 
 [DllImport（kernel32.dll）] 
 public static extern int GetDriveType（
 [MarshalAs（UnmanagedType.LPStr）] string rootPathName）; 
 
 [DllImport（cfgmgr32.dll）] 
 public static extern int CM_Connect_Machine（
 [MarshalAs（UnmanagedType.LPStr）] string uncServerName，
 ref IntPtr machineHandle ）; 
 
 [DllImport（cfgmgr32.dll）] 
 public static extern int CM_Disconnect_Machine（
 IntPtr machineHandle）; 
 
 [DllImport（cfgmgr32.dll）] 
 public static extern int CM_Locate_DevNode_Ex（
 ref IntPtr deviceHandle，
 int deviceId，
 uint flags， 
 IntPtr machineHandle）; 
 
 [DllImport（cfgmgr32.dll）] 
 public static extern int CM_Get_Child_Ex（
 ref IntPtr childDeviceHandle，
 IntPtr parentDeviceHandle，
 uint flags， 
 IntPtr machineHandle）; 
 
 [DllImport（cfgmgr32.dll）] 
 public static extern int CM_Get_Sibling_Ex（
 ref IntPtr siblingDeviceHandle，
 IntPtr deviceHandle，
 uint标志， 
 IntPtr machineHandle）; 
 
 [DllImport（cfgmgr32.dll）] 
 public static extern int 
 CM_Get_DevNode_Registry_Property_Ex（
 IntPtr deviceHandle，
 int property，
 IntPtr regDataType，
 IntPtr outBuffer，
 ref uint size，
 int flags，
 IntPtr machineHandle）; 
} 
}


I am currently trying to scan all USB Ports with their USB Hub (check if it is Root or not) and to which controller they are connectet.

To make it more visible:

USB Port1 (nothing plugged in)   -> USB Hub1   |                 |-> Controller 1
USB Port2 (Keyboard plugged in)  ->            |-> USB Root Hub  |-> Controller 2
USB Port3 (nothing plugged in)   -> USB Hub2   |                 |
USB Port4 (nothing plugged in)   ->            |-> USB Root Hub  |-> Controller3 (Mainboard)

I want to show the User all ports and connected Hubs as a tree. And if the USB Port with its controller are in use or not.

I hope you guys can understand what I am trying to describe. If you could give me some Keywords or even Code snippets i would greatly appreciate it.

PS.: Sorry for my bad english.

Here is the Code so far (I am using the .NetFramework 4.5.x):

USBPortScanner Class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Management;
using System.IO.Ports;

namespace USBPortScanner

{
    class USBPortScanner
    {
        static void Main(string[] args)
        {
            var usbDevices = GetUSBDevices();
            foreach (var usbDevice in usbDevices)
            {
                //Prints all defined porperties, they need to be defined in the USBDeviceInfo.cs!
                Console.WriteLine("Name: {0}\r\nCaption: {1}\r\nError Code: {2}\r\nDevice ID: {3}\r\nSystem Name: {4}\r\nStatus: {5}",
                    usbDevice.Name, usbDevice.Caption, usbDevice.ConfigManagerErrorCode, usbDevice.DeviceID, usbDevice.SystemName, usbDevice.Status);
                Console.WriteLine();
            }

            Console.Read();
        }
        //Sets the Properties for the device variable
        static List<USBDeviceInfo> GetUSBDevices()
        {
            List<USBDeviceInfo> devices = new List<USBDeviceInfo>();

            //Scanning all USBHubs with WMI
            using (var searcher = new ManagementObjectSearcher(@"Select * From Win32_USBHub"))
            {
                using (ManagementObjectCollection collection = searcher.Get())
                {
                    foreach (ManagementObject device in collection)
                    {

                        //To show all available data
                        //Console.WriteLine(device.Path);

                        //foreach (PropertyData prop in device.Properties)
                        //{
                        //    Console.WriteLine(prop.Name + ": " + prop.Value);
                        //}

                        //Console.WriteLine();

                        //Adds properties to device
                        devices.Add(new USBDeviceInfo(device));
                    }
                }
            }

            return devices;
        }
    }
}

USBDeviceInfo Class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Management;

namespace USBPortScanner
{

    class USBDeviceInfo
    {
        public USBDeviceInfo(ManagementObject device)
        {
            this.Name = device.GetPropertyValue("Name").ToString();
            this.Caption = device.GetPropertyValue("Caption").ToString();

            if (device.GetPropertyValue("ConfigManagerErrorCode") != null)
            {
                this.ConfigManagerErrorCode = (ErrorCode)device.GetPropertyValue("ConfigManagerErrorCode");
            }
            else
            {
                this.ConfigManagerErrorCode = ErrorCode.Device_is_not_present_not_working_properly_or_does_not_have_all_of_its_drivers_installed;
            }

            this.DeviceID = device.GetPropertyValue("DeviceID").ToString();
            this.SystemName = device.GetPropertyValue("SystemName").ToString();
            this.Status = device.GetPropertyValue("Status").ToString();
        }

        //Sets the variables above usable for our purpose in the Program.cs
        public string Name { get; private set; }
        public string Caption { get; private set; }
        public ErrorCode ConfigManagerErrorCode { get; private set; }
        public string DeviceID { get; private set; }
        public string SystemName { get; private set; }
        public string Status { get; private set; }
    }
    enum ErrorCode : uint
    {
        Device_is_working_properly = 0,
        Device_is_not_configured_correctly = 1,
        Windows_cannot_load_the_driver_for_this_device = 2,
        Driver_for_this_device_might_be_corrupted_or_the_system_may_be_low_on_memory_or_other_resources = 3,
        Device_is_not_working_properly_One_of_its_drivers_or_the_registry_might_be_corrupted = 4,
        Driver_for_the_device_requires_a_resource_that_Windows_cannot_manage = 5,
        Boot_configuration_for_the_device_conflicts_with_other_devices = 6,
        Cannot_filter = 7,
        Driver_loader_for_the_device_is_missing = 8,
        Device_is_not_working_properly_The_controlling_firmware_is_incorrectly_reporting_the_resources_for_the_device = 9,
        Device_cannot_start = 10,
        Device_failed = 11,
        Device_cannot_find_enough_free_resources_to_use = 12,
        Windows_cannot_verify_the_device_resources = 13,
        Device_cannot_work_properly_until_the_computer_is_restarted = 14,
        Device_is_not_working_properly_due_to_a_possible_reenumeration_problem = 15,
        Windows_cannot_identify_all_of_the_resources_that_the_device_uses = 16,
        Device_is_requesting_an_unknown_resource_type = 17,
        Device_drivers_must_be_reinstalled = 18,
        Failure_using_the_VxD_loader = 19,
        Registry_might_be_corrupted = 20,
        System_failure_If_changing_the_device_driver_is_ineffective_see_the_hardware_documentation_Windows_is_removing_the_device = 21,
        Device_is_disabled = 22,
        System_failure_If_changing_the_device_driver_is_ineffective_see_the_hardware_documentation = 23,
        Device_is_not_present_not_working_properly_or_does_not_have_all_of_its_drivers_installed = 24,
        Windows_is_still_setting_up_the_device = 25 | 26,
        Device_does_not_have_valid_log_configuration = 27,
        Device_drivers_are_not_installed = 28,
        Device_is_disabled_The_device_firmware_did_not_provide_the_required_resources = 29,
        Device_is_using_an_IRQ_resource_that_another_device_is_using = 30,
        Device_is_not_working_properly_Windows_cannot_load_the_required_device_drivers = 31,

    }
}

解决方案

I've found the solution myself. The Code below is a example i used from another site. I hope it will help the community too.

source: http://www.news2news.com/vfp/?example=545&ver=vcs&PHPSESSID=70ba6845606a96b355ab7f772fb14386

Code:

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Linq;

namespace DeviceEnumerator
{
    public class Program
    {
        public static void Main()
        {
            var deviceTree = new DeviceTree();

            foreach (var deviceClass in Win32.DeviceClasses)
            {
                Console.WriteLine("\n{0}:", deviceClass.Value);

                foreach (var device in deviceTree.DeviceNodes
                    .Where(d => d.ClassGuid == deviceClass.Key))
                {
                    Console.WriteLine(
                        "\t{1}: {0}",
                        device.Description,
                        device.EnumeratorName);
                }
            }

            Console.Write("\n\nAny key...");
            Console.ReadKey();
        }
    }

    public class DeviceTree : IDisposable
    {
        private IntPtr _machineHandle = IntPtr.Zero;
        private IntPtr _rootDeviceHandle = IntPtr.Zero;
        private DeviceNode _rootNode;

        // flat collection of all devices found
        private List< DeviceNode > _deviceNodes;

        public DeviceNode RootNode
        {
            get
            {
                return this._rootNode;
            }
        }

        public List< DeviceNode > DeviceNodes
        {
            get
            {
                return this._deviceNodes;
            }
        }

        public DeviceTree()
        {
            EnumerateDevices();
        }

        ~DeviceTree()
        {
            this.Dispose(false);
        }

        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                this._deviceNodes.Clear();
            }

            this.DisconnectFromMachine();
        }

        private void EnumerateDevices()
        {
            this.DisconnectFromMachine();

            // local machine assumed
            if (Win32.CM_Connect_Machine(
                null, ref this._machineHandle) != 0)
            {
                return;
            }

            try
            {
                Win32.CM_Locate_DevNode_Ex(
                    ref this._rootDeviceHandle,
                    0,
                    0,
                    this._machineHandle);

                // recursive enumeration
                this._rootNode = new DeviceNode(
                    this._rootDeviceHandle,
                    null,
                    this._machineHandle);
            }
            finally
            {
                this.DisconnectFromMachine();

                if (this._rootNode != null)
                {
                    this._deviceNodes = this._rootNode
                        .Flatten(node => node.Children).ToList();
                }
            }
        }

        private void DisconnectFromMachine()
        {
            if (this._machineHandle != IntPtr.Zero)
            {
                Win32.CM_Disconnect_Machine(this._machineHandle);
                this._machineHandle = IntPtr.Zero;
            }
        }
    }

    public class DeviceNode : IDisposable
    {
        private readonly DeviceNode _parentDevice;
        private readonly List< DeviceNode > _children;
        private readonly IntPtr _deviceHandle;
        private readonly IntPtr _machineHandle;

        private readonly Dictionary< int, string >
            _deviceProperties;

        public DeviceNode ParentDevice
        {
            get
            {
                return _parentDevice;
            }
        }

        public Dictionary< int, string > DeviceProperties
        {
            get
            {
                return _deviceProperties;
            }
        }

        public List< DeviceNode > Children
        {
            get
            {
                return this._children;
            }
        }

        public Guid ClassGuid
        {
            get
            {
                string buffer =
                    this.GetProperty(Win32.DevRegProperty.ClassGuid);

                var guid = new Guid();

                if (buffer.Length >= 32)
                {
                    try
                    {
                        guid = new Guid(buffer);
                    }
                    catch
                    {
                        guid = new Guid();
                    }
                }

                return guid;
            }
        }

        public string Description
        {
            get
            {
                return
                    GetProperty(Win32.DevRegProperty.DeviceDescription);
            }
        }

        public string FriendlyName
        {
            get
            {
                return
                    GetProperty(Win32.DevRegProperty.FriendlyName);
            }
        }

        public string EnumeratorName
        {
            get
            {
                return
                    GetProperty(Win32.DevRegProperty.EnumeratorName);
            }
        }

        public string LocationInfo
        {
            get
            {
                return
                    GetProperty(Win32.DevRegProperty.LocationInfo);
            }
        }

        public DeviceNode(IntPtr deviceHandle, DeviceNode parentDevice)
            : this(
                    deviceHandle, 
                    parentDevice, 
                    parentDevice._machineHandle)
        {
        }

        public DeviceNode(
            IntPtr deviceHandle,
            DeviceNode parentDevice,
            IntPtr machineHandle)
        {
            _deviceProperties = new Dictionary< int, string >();
            _children = new List< DeviceNode >();

            _deviceHandle = deviceHandle;
            _machineHandle = machineHandle;
            _parentDevice = parentDevice;

            EnumerateDeviceProperties();
            EnumerateChildren();
        }

        private string GetProperty(
            Win32.DevRegProperty devRegProperty)
        {
            return GetProperty((int)devRegProperty);
        }

        private string GetProperty(int index)
        {
            string buffer;
            var result = this._deviceProperties
                .TryGetValue(index, out buffer);
            return result ? buffer : string.Empty;
        }

        private void EnumerateDeviceProperties()
        {
            for (var index = 0; index < 64; index++)
            {
                uint bufsize = 2048;

                IntPtr buffer = 
                    Marshal.AllocHGlobal((int)bufsize);

                var result = 
                    Win32.CM_Get_DevNode_Registry_Property_Ex(
                        _deviceHandle,
                        index,
                        IntPtr.Zero,
                        buffer,
                        ref bufsize,
                        0,
                        _machineHandle);

                var propertyString = result == 0
                    ? Marshal.PtrToStringAnsi(buffer) 
                    : string.Empty;

                _deviceProperties.Add(index, propertyString);

                Marshal.FreeHGlobal(buffer);
            }
        }

        private void EnumerateChildren()
        {
            IntPtr ptrFirstChild = IntPtr.Zero;

            if (Win32.CM_Get_Child_Ex(
                ref ptrFirstChild, 
                _deviceHandle, 
                0, 
                _machineHandle) != 0)
            {
                return;
            }

            var ptrChild = ptrFirstChild;
            var ptrSibling = IntPtr.Zero;

            do
            {
                var childDevice = new DeviceNode(ptrChild, this);
                _children.Add(childDevice);

                if (Win32.CM_Get_Sibling_Ex(
                    ref ptrSibling, 
                    ptrChild, 
                    0, 
                    _machineHandle) != 0) break;

                ptrChild = ptrSibling;
            }
            while (true);
        }

        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                _deviceProperties.Clear();
            }
        }
    }

    internal static class LinqExtensionMethods
    {
        public static IEnumerable< T > Return< T >(T element)
        {
            yield return element;
        }

        public static IEnumerable< T > StartWith< T >(
            this IEnumerable< T > list, T element)
        {
            return Return(element).Concat(list);
        }

        public static IEnumerable< TEntity > Flatten< TEntity >(
            this TEntity element,
            Func< TEntity, IEnumerable< TEntity > > childSelector)
        {
            if (childSelector(element) != null)
                return childSelector(element)
                    .SelectMany(child => child.Flatten(childSelector))
                    .StartWith(element);

            var items = new List< TEntity > { element };
            return items;
        }
    }

    public static class Win32
    {
        // this is a partial list
        public static readonly
            Dictionary< Guid, string > DeviceClasses =
            new Dictionary< Guid, string >
            {
                { new Guid("{4d36e967-e325-11ce-bfc1-08002be10318}"), 
                    "Disk Drives" },
                { new Guid("{4d36e968-e325-11ce-bfc1-08002be10318}"), 
                    "Display Adapters" },
                { new Guid("{4d36e96b-e325-11ce-bfc1-08002be10318}"), 
                    "Keyboards" },
                { new Guid("{4d36e96f-e325-11ce-bfc1-08002be10318}"), 
                    "Mice" },
            };

        public enum DevRegProperty : uint
        {
            DeviceDescription = 1,
            HardwareId = 2,
            CompatibleIds = 3,
            Unused0 = 4,
            Service = 5,
            Unused1 = 6,
            Unused2 = 7,
            Class = 8,
            ClassGuid = 9,
            Driver = 0x0a,
            ConfigFlags = 0x0b,
            Mfg = 0x0c,
            FriendlyName = 0x0d,
            LocationInfo = 0x0e,
            PhysicalDeviceObjectName = 0x0f,
            Capabilities = 0x10,
            UiNumber = 0x11,
            UpperFilters = 0x12,
            LowerFilters = 0x13,
            BusTypeGuid = 0x014,
            LegacyBusType = 0x15,
            BusNumber = 0x16,
            EnumeratorName = 0x17,
        }

        [DllImport("kernel32.dll")]
        public static extern uint GetLogicalDrives();

        [DllImport("kernel32.dll")]
        public static extern int GetDriveType(
            [MarshalAs(UnmanagedType.LPStr)] string rootPathName);

        [DllImport("cfgmgr32.dll")]
        public static extern int CM_Connect_Machine(
            [MarshalAs(UnmanagedType.LPStr)] string uncServerName,
            ref IntPtr machineHandle);

        [DllImport("cfgmgr32.dll")]
        public static extern int CM_Disconnect_Machine(
            IntPtr machineHandle);

        [DllImport("cfgmgr32.dll")]
        public static extern int CM_Locate_DevNode_Ex(
            ref IntPtr deviceHandle,
            int deviceId,
            uint flags,
            IntPtr machineHandle);

        [DllImport("cfgmgr32.dll")]
        public static extern int CM_Get_Child_Ex(
            ref IntPtr childDeviceHandle,
            IntPtr parentDeviceHandle,
            uint flags,
            IntPtr machineHandle);

        [DllImport("cfgmgr32.dll")]
        public static extern int CM_Get_Sibling_Ex(
            ref IntPtr siblingDeviceHandle,
            IntPtr deviceHandle,
            uint flags,
            IntPtr machineHandle);

        [DllImport("cfgmgr32.dll")]
        public static extern int 
            CM_Get_DevNode_Registry_Property_Ex(
                IntPtr deviceHandle,
                int property,
                IntPtr regDataType,
                IntPtr outBuffer,
                ref uint size,
                int flags,
                IntPtr machineHandle);
    }
}

这篇关于C＃如何检查USB端口与USB集线器和使用的控制器？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！

查看全文
相关文章
C#/.NET最新文章
热门教程
热门工具
登录 关闭
扫码关注1秒登录
发送“验证码”获取 | 15天全站免登陆