如何在 C# 中读取 USB (PnP) 设备的 WMI 数据，在本例中为硬件 ID？

Question

如何从 USB 设备获取硬件 ID？我知道如何使用设备管理器获取该 ID，但我想通过 C# 获取它。那可能吗？这就是我已经完成的，但是如果硬件包含供应商 ID (VID) 和产品 ID (PID)，那么它不会给我提供硬件：

ManagementObjectSearcher USB = new ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive WHERE InterfaceType='USB'");
ManagementObjectCollection USBinfo = USB.Get();

foreach (ManagementObject MO in USBinfo)
{
    serialNumber = (string)MO["DeviceID"];
    name = (string)MO["Name"];
    Drives.Add(new KeyValuePair<String, String>(name, serialNumber));
}

我也尝试过使用 "PNPDeviceID" 和 "SerialNumber" 而不是 "DeviceID"，但这也没有回复我需要的硬件 ID。

Answer 1

在控制台应用程序中，添加引用-->.Net-->system.Management-->添加

namespace ConsoleApplication1
{
  using System;
  using System.Collections.Generic;
  using System.Management; // need to add System.Management to your project references.

  class Program
  {
    static void Main(string[] args)
    {
      var usbDevices = GetUSBDevices();

      foreach (var usbDevice in usbDevices)
      {
        Console.WriteLine("Device ID: {0}, PNP Device ID: {1}, Description: {2}",
            usbDevice.DeviceID, usbDevice.PnpDeviceID, usbDevice.Description);
      }

      Console.Read();
    }

    static List<USBDeviceInfo> GetUSBDevices()
    {
      List<USBDeviceInfo> devices = new List<USBDeviceInfo>();
      ManagementObjectCollection collection;

      using (var searcher = new ManagementObjectSearcher(@"Select * From Win32_USBHub"))
        collection = searcher.Get();      

      foreach (var device in collection)
      {
        devices.Add(new USBDeviceInfo(
        (string)device.GetPropertyValue("DeviceID"),
        (string)device.GetPropertyValue("PNPDeviceID"),
        (string)device.GetPropertyValue("Description")
        ));
      }

      collection.Dispose();
      return devices;
    }
  }

  class USBDeviceInfo
  {
    public USBDeviceInfo(string deviceID, string pnpDeviceID, string description)
    {
      this.DeviceID = deviceID;
      this.PnpDeviceID = pnpDeviceID;
      this.Description = description;
    }

    public string DeviceID { get; private set; }
    public string PnpDeviceID { get; private set; }
    public string Description { get; private set; }
  }
}

Answer 2

原始答案（请参阅下面的更新答案）

您需要查看 Win32_PnPEntity WMI class。根据提到的描述，您可以看到，您只需要检查 HardwareID.

以下代码以 "quick and dirty" 方式显示，我建议创建一个 Win32_PnpEntity class 通过属性公开数据。

ManagementObjectSearcher searcher = new ManagementObjectSearcher("Select * From Win32_PnPEntity");
ManagementObjectCollection deviceCollection = searcher.Get();

foreach (var device in deviceCollection)
{
    try
    {
        string caption = (string)device.GetPropertyValue("Caption");

        if (caption == null)
            continue;

        Console.WriteLine(caption);

        string[] hardwareIDs = (string[])device.GetPropertyValue("HardwareID");

        if (hardwareIDs == null)
            continue;

        foreach (string hardwareID in hardwareIDs)
        {
            Console.WriteLine(hardwareID);
        }

        Console.WriteLine();
    }
    catch (Exception e)
    {
        Console.WriteLine(e);
    }
}

更新答案

由于一般问题是如何在 C# 中读取 USB (PnP) 设备的 WMI 数据，在这种情况下是硬件 ID？，我写了一个 Win32_PnpEntity class（删除注释，因为 post 限制为 30000 个字符？如果有人想要注释版本，请给我留言）它采用 ManageementBasObject 并提供所有数据给定实体作为属性。

用法：

ManagementObjectSearcher searcher = new ManagementObjectSearcher("Select * From Win32_PnPEntity");
ManagementObjectCollection deviceCollection = searcher.Get();

foreach (var entity in deviceCollection)
{
    Win32_PnPEntity device = new Win32_PnPEntity(entity);

    Console.WriteLine($"Caption: {device.Caption}");
    Console.WriteLine($"Description: {device.Description}");
    Console.WriteLine($"Number of hardware IDs: {device.HardwareID.Length}");

    foreach (string hardwareID in device.HardwareID)
    {
        Console.WriteLine(hardwareID);
    }

    Console.WriteLine();
}

Win32_PnpEntity class:

public class Win32_PnPEntity
{
    public enum AvailabilityEnum
    {
        /// <summary>
        /// Represents the meaning "Other".
        /// </summary>
        Other = 0x01,

        /// <summary>
        /// Represents the meaning "Unknown".
        /// </summary>
        Unknown = 0x02,

        /// <summary>
        /// Represents the meaning "Running or Full Power".
        /// </summary>
        RunningOrFullPower = 0x03,

        /// <summary>
        // Represents the meaning "Warning".
        /// </summary>
        Warning = 0x04,

        /// <summary>
        /// Represents the meaning "In Test".
        /// </summary>
        InTest = 0x05,

        /// <summary>
        /// Represents the meaning "Not Applicable".
        /// </summary>
        NotApplicable = 0x06,

        /// <summary>
        /// Represents the maning "Power Off".
        /// </summary>
        PowerOff = 0x07,

        /// <summary>
        /// Represents the meaning "Off Line".
        /// </summary>
        OffLine = 0x08,

        /// <summary>
        /// Represents the meaning "Off Duty".
        /// </summary>
        OffDuty = 0x09,

        /// <summary>
        /// Represents the meaning "Degraded".
        /// </summary>
        Degraded = 0x0A,

        /// <summary>
        /// Represents the meaning "Not Installed".
        /// </summary>
        NotInstalled = 0x0B,

        /// <summary>
        /// Represents the meaning "Install Error".
        /// </summary>
        InstallError = 0x0C,

        /// <summary>
        /// Represents the meaning "Power Save - Unknown".
        /// The device is known to be in a power save mode, but its exact status is unknown.
        /// </summary>
        PowerSave_Unknown = 0x0D,

        /// <summary>
        /// Represents the meaning "Power Save - Low Power Mode".
        /// The device is in a power save state but still functioning, and may exhibit degraded performance.
        /// </summary>
        PowerSave_LowPowerMode = 0x0E,

        /// <summary>
        /// Represents the meaning "Power Save - Standby".
        /// The device is not functioning, but could be brought to full power quickly.
        /// </summary>
        PowerSave_Standyby = 0x0F,

        /// <summary>
        /// Represents the meaning "Power Cycle".
        /// </summary>
        PowerCycle = 0x10,

        /// <summary>
        /// Represents the meaning "Power Save - Warning".
        /// The device is in a warning state, though also in a power save mode.
        /// </summary>
        PowerSave_Warning = 0x11
    }

    public enum ConfigManagerErrorCodeEnum
    {
        /// <summary>
        /// Represents the meaning "Unknown", not supported in the original WMI class.
        /// </summary>
        Unknown = 0xFF,

        /// <summary>
        /// Represents the meaning "Device is working properly.".
        /// </summary>
        WorkingProperly = 0x00,

        /// <summary>
        /// Represents the meaning "Device is not configured correctly.".
        /// </summary>
        DeviceNotConfiguredError = 0x01,

        /// <summary>
        /// Represents the meaning "Windows cannot load the driver for this device.".
        /// </summary>
        CannotLoadDriverError = 0x02,

        /// <summary>
        /// Represents the meaning "Driver for this device might be corrupted, or the system may be low on memory or other resources.".
        /// </summary>
        DriverCorruptedError = 0x03,

        /// <summary>
        /// Represents the meaning "Device is not working properly. One of its drivers or the registry might be corrupted.".
        /// </summary>
        NotWorkingProperlyError = 0x04,

        /// <summary>
        /// Represents the meaning "Driver for the device requires a resource that Windows cannot manage.".
        /// </summary>
        DriverResourceError = 0x05,

        /// <summary>
        /// Represents the meaning "Boot configuration for the device conflicts with other devices.".
        /// </summary>
        BootConfigurationError = 0x06,

        /// <summary>
        /// Represents the meaning "Cannot filter.".
        /// </summary>
        CannotFilterError = 0x07,

        /// <summary>
        /// Represents the meaning "Driver loader for the device is missing.".
        /// </summary>
        DriverLoaderMissingError = 0x08,

        /// <summary>
        /// Represents the meaning "Device is not working properly. The controlling firmware is incorrectly reporting the resources for the device.".
        /// </summary>
        DeviceNotWorkingProperlyFirmwareError = 0x09,

        /// <summary>
        /// Represents the meaning "Device cannot start.".
        /// </summary>
        DeviceCannotStartError = 0x0A,

        /// <summary>
        /// Represents the meaning "Device failed.".
        /// </summary>
        DeviceFailedError = 0x0B,

        /// <summary>
        /// Represents the meaning "Device cannot find enough free resources to use.".
        /// </summary>
        DeviceTooFewResourcesError = 0x0C,

        /// <summary>
        /// Represents the meaning "Windows cannot verify the device's resources.".
        /// </summary>
        VerifyDeviceResourceError = 0x0D,

        /// <summary>
        /// Represents the meaning "Device cannot work properly until the computer is restarted.".
        /// </summary>
        DeviceCannotWorkProperlyUnitlRestartError = 0x0E,

        /// <summary>
        /// Represents the meaning "Device is not working properly due to a possible re-enumeration problem.".
        /// </summary>
        DeviceNotWorkingProperlyReenumerationError = 0x0F,

        /// <summary>
        /// Represents the meaning "Windows cannot identify all of the resources that the device uses.".
        /// </summary>
        IdentifyResourcesForDeviceError = 0x10,

        /// <summary>
        /// Represents the meaning "Device is requesting an unknown resource type.".
        /// </summary>
        UnknownResourceTypeError = 0x11,

        /// <summary>
        /// Represents the meaning "Device drivers must be reinstalled.".
        /// </summary>
        DeviceDriversMustBeResinstalledError = 0x12,

        /// <summary>
        /// Represents the meaning "Failure using the VxD loader.".
        /// </summary>
        FailureUsingVxDLoaderError = 0x13,

        /// <summary>
        /// Represents the meaning "Registry might be corrupted.".
        /// </summary>
        RegistryMightBeCorruptedError = 0x14,

        /// <summary>
        /// Represents the meaning "System failure. If changing the device driver is ineffective, see the hardware documentation. Windows is removing the device.".
        /// </summary>
        SystemFailureRemovingDeviceError = 0x15,

        /// <summary>
        /// Represents the meaning "Device is disabled.".
        /// </summary>
        DeviceDisabledError = 0x16,

        /// <summary>
        /// Represents the meaning "System failure. If changing the device driver is ineffective, see the hardware documentation.".
        /// </summary>
        SystemFailureError = 0x17,

        /// <summary>
        /// Represents the meaning "Device is not present, not working properly, or does not have all of its drivers installed.".
        /// </summary>
        DeviceNotPresentError = 0x18,

        /// <summary>
        /// Represents the meaning "Windows is still setting up the device.".
        /// </summary>
        StillSettingUpTheDeviceError = 0x19,

        /// <summary>
        /// Represents the meaning "Windows is still setting up the device.".
        /// </summary>
        StillSettingUpTheDeviceError_2 = 0x1A,

        /// <summary>
        /// Represents the meaning "Device does not have valid log configuration.".
        /// </summary>
        InvalidDeviceLogConfigurationError = 0x1B,

        /// <summary>
        /// Represents the meaning "Device drivers are not installed.".
        /// </summary>
        DeviceDriversNotInstalledError = 0x1C,

        /// <summary>
        /// Represents the meaning "Device is disabled. The device firmware did not provide the required resources.".
        /// </summary>
        DeviceDisabledDueToFirmwareResourceError = 0x1D,

        /// <summary>
        /// Represents the meaning "Device is using an IRQ resource that another device is using.".
        /// </summary>
        IRQConflictError = 0x1E,

        /// <summary>
        /// Represents the meaning "Device is not working properly. Windows cannot load the required device drivers.".
        /// </summary>
        DeviceNotWorkingProperlyCannotLoadDrivers = 0x1F
    }

    public enum StatusInfoEnum
    {
        /// <summary>
        /// Represents the meaning "Other".
        /// </summary>
        Other = 0x01,

        /// <summary>
        /// Represents the meaning "Unknown".
        /// </summary>
        Unknown = 0x02,

        /// <summary>
        /// Represents the meaning "Enabled".
        /// </summary>
        Enabled = 0x03,

        /// <summary>
        /// Represents the meaning "Disabled".
        /// </summary>
        Disabled = 0x04,

        /// <summary>
        /// Represents the meaning "Not Applicable".
        /// </summary>
        NotApplicable = 0x05
    }

    private ManagementBaseObject managementObject;

    public Win32_PnPEntity(ManagementBaseObject managementObject)
    {
        if (managementObject == null)
        {
            throw new ArgumentNullException(nameof(managementObject));
        }

        this.managementObject = managementObject;
    }

    public AvailabilityEnum Availability
    {
        get
        {
            try
            {
                Int16 value = (Int16)this.managementObject.GetPropertyValue("Availability");

                if (!Enum.IsDefined(typeof(AvailabilityEnum), value))
                {
                    // Handle not supported values here
                    throw new NotSupportedException($"The value {value} is not supported for conversion to the {nameof(AvailabilityEnum)} enumeration.");
                }

                return (AvailabilityEnum)value;
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return AvailabilityEnum.Unknown;
            }
        }
    }

    public string Caption
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("Caption");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public string ClassGuid
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("ClassGuid");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public string[] CompatibleID
    {
        get
        {
            try
            {
                string[] value = (string[])this.managementObject.GetPropertyValue("ClassGuid");

                if (value == null)
                    // Handle null value.
                    return new string[0];

                return value;
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return new string[0];
            }
        }
    }

    public ConfigManagerErrorCodeEnum ConfigManagerErrorCode
    {
        get
        {
            try
            {
                Int16 value = (Int16)this.managementObject.GetPropertyValue("ConfigManagerErrorCode");

                if (!Enum.IsDefined(typeof(ConfigManagerErrorCodeEnum), value))
                {
                    // Handle not supported values here
                    throw new NotSupportedException($"The value {value} is not supported for conversion to the {nameof(ConfigManagerErrorCodeEnum)} enumeration.");
                }

                return (ConfigManagerErrorCodeEnum)value;
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return ConfigManagerErrorCodeEnum.Unknown;
            }
        }
    }

    public bool ConfigManagerUserConfig
    {
        get
        {
            try
            {
                return (bool)this.managementObject.GetPropertyValue("ConfigManagerUserConfig");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return false;
            }
        }
    }

    public string CreationClassName
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("CreationClassName");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public string Description
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("Description");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public string DeviceID
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("DeviceID");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public bool ErrorCleared
    {
        get
        {
            try
            {
                return (bool)this.managementObject.GetPropertyValue("ErrorCleared");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return false;
            }
        }
    }

    public string ErrorDescription
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("ErrorDescription");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public string[] HardwareID
    {
        get
        {
            try
            {
                string[] value = (string[])this.managementObject.GetPropertyValue("HardwareID");

                if (value == null)
                    // Handle null value.
                    return new string[0];

                return value;
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return new string[0];
            }
        }
    }

    public DateTime InstallDate
    {
        get
        {
            try
            {
                DateTime value = (DateTime)this.managementObject.GetPropertyValue("InstallDate");

                if (value == null)
                    // Handle null value.
                    return DateTime.MinValue;

                return value;
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return DateTime.MinValue;
            }
        }
    }

    public UInt32 LastErrorCode
    {
        get
        {
            try
            {
                return (UInt32)this.managementObject.GetPropertyValue("LastErrorCode");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return 0;
            }
        }
    }

    public string Manufacturer
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("Manufacturer");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public string Name
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("Name");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public string PNPClass
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("PNPClass");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public string PNPDeviceID
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("PNPDeviceID");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public UInt16[] PowerManagementCapabilities
    {
        get
        {
            try
            {
                UInt16[] value = (UInt16[])this.managementObject.GetPropertyValue("PowerManagementCapabilities");

                if (value == null)
                    // Handle null value.
                    return new UInt16[0];

                return value;
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return new UInt16[0];
            }
        }
    }

    public bool PowerManagementSupported
    {
        get
        {
            try
            {
                return (bool)this.managementObject.GetPropertyValue("PowerManagementSupported");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return false;
            }
        }
    }

    public bool Present
    {
        get
        {
            try
            {
                return (bool)this.managementObject.GetPropertyValue("Present");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return false;
            }
        }
    }

    public string Service
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("Service");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public string Status
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("Status");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public StatusInfoEnum StatusInfo
    {
        get
        {
            try
            {
                Int16 value = (Int16)this.managementObject.GetPropertyValue("StatusInfo");

                if (!Enum.IsDefined(typeof(StatusInfoEnum), value))
                {
                    // Handle not supported values here
                    throw new NotSupportedException($"The value {value} is not supported for conversion to the {nameof(StatusInfoEnum)} enumeration.");
                }

                return (StatusInfoEnum)value;
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return StatusInfoEnum.NotApplicable;
            }
        }
    }

    public string SystemCreationClassName
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("SystemCreationClassName");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }

    public string SystemName
    {
        get
        {
            try
            {
                return (string)this.managementObject.GetPropertyValue("SystemName");
            }
            catch
            {
                // Handle exception caused by accessing the property value.
                return "Unknown";
            }
        }
    }
}

如何在 C# 中读取 USB (PnP) 设备的 WMI 数据，在本例中为硬件 ID？

How to read WMI data of a USB (PnP) device, in this case the hardware ids, in C#?

c#

usb

wmi

wmi-query

device-manager