如何在C＃中读取USB（PnP）设备的WMI数据，在这种情况下是硬件ID？

Question

How can I get the hardware id from an USB device? I know how to get that id with device-manager, but I want to get it via C#. Is that possible? This is what I´ve done already, but that delivers me not the hardware if which consists of the vendor id (VID) and the product 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));
}

I also tried it with "PNPDeviceID" and "SerialNumber" instead of "DeviceID", but that also doesn´t replys the hardware-id that I need.

Answer 1

Original answer (see updated answer below)

You need to take a look at the Win32_PnPEntity WMI class. According to the mentioned description you can see, that you just need to check for HardwareID .

The following code show's that in a "quick and dirty" way, I would suggest creating a Win32_PnpEntity class which exposes the data via properties.

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);
    }
}

Updated answer

As the generic question is How to read WMI data of USB (PnP) device in C#, in this case the hardware ids? , I've written a Win32_PnpEntity class (stripped of comments as the post is limited to 30000 characters? If anyone want's the commented version, drop me a line) which takes a ManageementBasObject and provides all data of that given entity as properties.

Usage:

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();
}

The 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";
            }
        }
    }
}

Answer 2

In Console application, add refrence-->.Net-->system.Management-->add

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; }
  }
}