如何使用 C# 获取总线报告的设备描述

Question

I am trying to get a value from windows device manager(windows 7).

The property name i am searching for is Bus Reported Device Description.

I am using the below code to get device name.

Please help me to get the Bus reported device description.

 void OtherDevices()
    {
        ManagementObjectSearcher deviceList = new ManagementObjectSearcher("Select Name, Status from Win32_PnPEntity");
        if (deviceList != null)
        {
            foreach (ManagementObject device in deviceList.Get())
            {
                string name = device.GetPropertyValue("Name").ToString();
                if (name.Contains("iC5000"))
                {
                    dgv_HWlist.Rows.Add(name);
                    // break;
                }
            }
        }
    }

Answer 1

namespace flash_tool.common.Utils
{
    using System;
    using System.Text;
    using System.Runtime.InteropServices;
    using System.Collections.Generic;

    public class Win32DeviceMgmt
    {
        [Flags]
        public enum DiGetClassFlags : uint
        {
            DIGCF_DEFAULT = 0x00000001,  // only valid with DIGCF_DEVICEINTERFACE
            DIGCF_PRESENT = 0x00000002,
            DIGCF_ALLCLASSES = 0x00000004,
            DIGCF_PROFILE = 0x00000008,
            DIGCF_DEVICEINTERFACE = 0x00000010,
        }
        /// <summary>
        /// Device registry property codes
        /// </summary>
        public enum SPDRP : uint
        {
            /// <summary>
            /// DeviceDesc (R/W)
            /// </summary>
            SPDRP_DEVICEDESC = 0x00000000,

            /// <summary>
            /// HardwareID (R/W)
            /// </summary>
            SPDRP_HARDWAREID = 0x00000001,

            /// <summary>
            /// CompatibleIDs (R/W)
            /// </summary>
            SPDRP_COMPATIBLEIDS = 0x00000002,

            /// <summary>
            /// unused
            /// </summary>
            SPDRP_UNUSED0 = 0x00000003,

            /// <summary>
            /// Service (R/W)
            /// </summary>
            SPDRP_SERVICE = 0x00000004,

            /// <summary>
            /// unused
            /// </summary>
            SPDRP_UNUSED1 = 0x00000005,

            /// <summary>
            /// unused
            /// </summary>
            SPDRP_UNUSED2 = 0x00000006,

            /// <summary>
            /// Class (R--tied to ClassGUID)
            /// </summary>
            SPDRP_CLASS = 0x00000007,

            /// <summary>
            /// ClassGUID (R/W)
            /// </summary>
            SPDRP_CLASSGUID = 0x00000008,

            /// <summary>
            /// Driver (R/W)
            /// </summary>
            SPDRP_DRIVER = 0x00000009,

            /// <summary>
            /// ConfigFlags (R/W)
            /// </summary>
            SPDRP_CONFIGFLAGS = 0x0000000A,

            /// <summary>
            /// Mfg (R/W)
            /// </summary>
            SPDRP_MFG = 0x0000000B,

            /// <summary>
            /// FriendlyName (R/W)
            /// </summary>
            SPDRP_FRIENDLYNAME = 0x0000000C,

            /// <summary>
            /// LocationInformation (R/W)
            /// </summary>
            SPDRP_LOCATION_INFORMATION = 0x0000000D,

            /// <summary>
            /// PhysicalDeviceObjectName (R)
            /// </summary>
            SPDRP_PHYSICAL_DEVICE_OBJECT_NAME = 0x0000000E,

            /// <summary>
            /// Capabilities (R)
            /// </summary>
            SPDRP_CAPABILITIES = 0x0000000F,

            /// <summary>
            /// UiNumber (R)
            /// </summary>
            SPDRP_UI_NUMBER = 0x00000010,

            /// <summary>
            /// UpperFilters (R/W)
            /// </summary>
            SPDRP_UPPERFILTERS = 0x00000011,

            /// <summary>
            /// LowerFilters (R/W)
            /// </summary>
            SPDRP_LOWERFILTERS = 0x00000012,

            /// <summary>
            /// BusTypeGUID (R)
            /// </summary>
            SPDRP_BUSTYPEGUID = 0x00000013,

            /// <summary>
            /// LegacyBusType (R)
            /// </summary>
            SPDRP_LEGACYBUSTYPE = 0x00000014,

            /// <summary>
            /// BusNumber (R)
            /// </summary>
            SPDRP_BUSNUMBER = 0x00000015,

            /// <summary>
            /// Enumerator Name (R)
            /// </summary>
            SPDRP_ENUMERATOR_NAME = 0x00000016,

            /// <summary>
            /// Security (R/W, binary form)
            /// </summary>
            SPDRP_SECURITY = 0x00000017,

            /// <summary>
            /// Security (W, SDS form)
            /// </summary>
            SPDRP_SECURITY_SDS = 0x00000018,

            /// <summary>
            /// Device Type (R/W)
            /// </summary>
            SPDRP_DEVTYPE = 0x00000019,

            /// <summary>
            /// Device is exclusive-access (R/W)
            /// </summary>
            SPDRP_EXCLUSIVE = 0x0000001A,

            /// <summary>
            /// Device Characteristics (R/W)
            /// </summary>
            SPDRP_CHARACTERISTICS = 0x0000001B,

            /// <summary>
            /// Device Address (R)
            /// </summary>
            SPDRP_ADDRESS = 0x0000001C,

            /// <summary>
            /// UiNumberDescFormat (R/W)
            /// </summary>
            SPDRP_UI_NUMBER_DESC_FORMAT = 0X0000001D,

            /// <summary>
            /// Device Power Data (R)
            /// </summary>
            SPDRP_DEVICE_POWER_DATA = 0x0000001E,

            /// <summary>
            /// Removal Policy (R)
            /// </summary>
            SPDRP_REMOVAL_POLICY = 0x0000001F,

            /// <summary>
            /// Hardware Removal Policy (R)
            /// </summary>
            SPDRP_REMOVAL_POLICY_HW_DEFAULT = 0x00000020,

            /// <summary>
            /// Removal Policy Override (RW)
            /// </summary>
            SPDRP_REMOVAL_POLICY_OVERRIDE = 0x00000021,

            /// <summary>
            /// Device Install State (R)
            /// </summary>
            SPDRP_INSTALL_STATE = 0x00000022,

            /// <summary>
            /// Device Location Paths (R)
            /// </summary>
            SPDRP_LOCATION_PATHS = 0x00000023,
        }
        private const UInt32 DICS_FLAG_GLOBAL = 0x00000001;
        private const UInt32 DIREG_DEV = 0x00000001;
        private const UInt32 KEY_QUERY_VALUE = 0x0001;

        /// <summary>
        /// The SP_DEVINFO_DATA structure defines a device instance that is a member of a device information set.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        private struct SP_DEVINFO_DATA
        {
            public UInt32 cbSize;
            public Guid ClassGuid;
            public UInt32 DevInst;
            public UIntPtr Reserved;
        };


        [StructLayout(LayoutKind.Sequential)]
        struct DEVPROPKEY
        {
            public Guid fmtid;
            public UInt32 pid;
        }


        [DllImport("setupapi.dll")]
        private static extern Int32 SetupDiDestroyDeviceInfoList(IntPtr DeviceInfoSet);

        [DllImport("setupapi.dll", SetLastError = true)]
        private static extern bool SetupDiEnumDeviceInfo(IntPtr DeviceInfoSet, UInt32 MemberIndex, ref SP_DEVINFO_DATA DeviceInterfaceData);

        [DllImport("setupapi.dll", SetLastError = true)]
        private static extern IntPtr SetupDiGetClassDevs(ref Guid gClass, UInt32 iEnumerator, UInt32 hParent, DiGetClassFlags nFlags);

        [DllImport("Setupapi", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr SetupDiOpenDevRegKey(IntPtr hDeviceInfoSet, ref SP_DEVINFO_DATA deviceInfoData, uint scope,
            uint hwProfile, uint parameterRegistryValueKind, uint samDesired);

        [DllImport("advapi32.dll", CharSet = CharSet.Unicode, EntryPoint = "RegQueryValueExW", SetLastError = true)]
        private static extern int RegQueryValueEx(IntPtr hKey, string lpValueName, int lpReserved, out uint lpType,
            byte[] lpData, ref uint lpcbData);

        [DllImport("advapi32.dll", CharSet = CharSet.Ansi, SetLastError = true, ExactSpelling = true)]
        private static extern int RegCloseKey(IntPtr hKey);

        [DllImport("kernel32.dll")]
        private static extern Int32 GetLastError();

        const int BUFFER_SIZE = 1024;

        [DllImport("setupapi.dll", SetLastError = true)]
        static extern bool SetupDiClassGuidsFromName(string ClassName,
            ref Guid ClassGuidArray1stItem, UInt32 ClassGuidArraySize,
            out UInt32 RequiredSize);

        [DllImport("setupapi.dll")]
        private static extern Int32 SetupDiClassNameFromGuid(ref Guid ClassGuid,
            StringBuilder className, Int32 ClassNameSize, ref Int32 RequiredSize);

        /// <summary>
        /// The SetupDiGetDeviceRegistryProperty function retrieves the specified device property.
        /// This handle is typically returned by the SetupDiGetClassDevs or SetupDiGetClassDevsEx function.
        /// </summary>
        /// <param Name="DeviceInfoSet">Handle to the device information set that contains the interface and its underlying device.</param>
        /// <param Name="DeviceInfoData">Pointer to an SP_DEVINFO_DATA structure that defines the device instance.</param>
        /// <param Name="Property">Device property to be retrieved. SEE MSDN</param>
        /// <param Name="PropertyRegDataType">Pointer to a variable that receives the registry data Type. This parameter can be NULL.</param>
        /// <param Name="PropertyBuffer">Pointer to a buffer that receives the requested device property.</param>
        /// <param Name="PropertyBufferSize">Size of the buffer, in bytes.</param>
        /// <param Name="RequiredSize">Pointer to a variable that receives the required buffer size, in bytes. This parameter can be NULL.</param>
        /// <returns>If the function succeeds, the return value is nonzero.</returns>
        [DllImport("setupapi.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool SetupDiGetDeviceRegistryProperty(
            IntPtr DeviceInfoSet,
            ref SP_DEVINFO_DATA DeviceInfoData,
            SPDRP Property,
            out UInt32 PropertyRegDataType,
            byte[] PropertyBuffer,
            uint PropertyBufferSize,
            out UInt32 RequiredSize);

        [DllImport("setupapi.dll", SetLastError = true)]
        static extern bool SetupDiGetDevicePropertyW(
            IntPtr deviceInfoSet,
            [In] ref SP_DEVINFO_DATA DeviceInfoData,
            [In] ref DEVPROPKEY propertyKey,
            [Out] out UInt32 propertyType,
            byte[] propertyBuffer,
            UInt32 propertyBufferSize,
            out UInt32 requiredSize,
            UInt32 flags);

        const int utf16terminatorSize_bytes = 2;

        public struct DeviceInfo
        {
            public string name;
            public string description;
            public string bus_description;
        }

        static DEVPROPKEY DEVPKEY_Device_BusReportedDeviceDesc;

        static Win32DeviceMgmt()
        {
            DEVPKEY_Device_BusReportedDeviceDesc = new DEVPROPKEY();
            DEVPKEY_Device_BusReportedDeviceDesc.fmtid = new Guid(0x540b947e, 0x8b40, 0x45bc, 0xa8, 0xa2, 0x6a, 0x0b, 0x89, 0x4c, 0xbd, 0xa2);
            DEVPKEY_Device_BusReportedDeviceDesc.pid = 4;
        }

        public static List<DeviceInfo> GetAllCOMPorts()
        {
            Guid[] guids = GetClassGUIDs("Ports");
            List<DeviceInfo> devices = new List<DeviceInfo>();
            for (int index = 0; index < guids.Length; index++)
            {
                IntPtr hDeviceInfoSet = SetupDiGetClassDevs(ref guids[index], 0, 0, DiGetClassFlags.DIGCF_PRESENT);
                if (hDeviceInfoSet == IntPtr.Zero)
                {
                    throw new Exception("Failed to get device information set for the COM ports");
                }

                try
                {
                    UInt32 iMemberIndex = 0;
                    while (true)
                    {
                        SP_DEVINFO_DATA deviceInfoData = new SP_DEVINFO_DATA();
                        deviceInfoData.cbSize = (uint)Marshal.SizeOf(typeof(SP_DEVINFO_DATA));
                        bool success = SetupDiEnumDeviceInfo(hDeviceInfoSet, iMemberIndex, ref deviceInfoData);
                        if (!success)
                        {
                            // No more devices in the device information set
                            break;
                        }

                        DeviceInfo deviceInfo = new DeviceInfo();
                        deviceInfo.name = GetDeviceName(hDeviceInfoSet, deviceInfoData);
                        deviceInfo.description = GetDeviceDescription(hDeviceInfoSet, deviceInfoData);
                        deviceInfo.bus_description = GetDeviceBusDescription(hDeviceInfoSet, deviceInfoData);
                        devices.Add(deviceInfo);

                        iMemberIndex++;
                    }
                }
                finally
                {
                    SetupDiDestroyDeviceInfoList(hDeviceInfoSet);
                }
            }
            return devices;
        }

        private static string GetDeviceName(IntPtr pDevInfoSet, SP_DEVINFO_DATA deviceInfoData)
        {
            IntPtr hDeviceRegistryKey = SetupDiOpenDevRegKey(pDevInfoSet, ref deviceInfoData,
                DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_QUERY_VALUE);
            if (hDeviceRegistryKey == IntPtr.Zero)
            {
                throw new Exception("Failed to open a registry key for device-specific configuration information");
            }

            byte[] ptrBuf = new byte[BUFFER_SIZE];
            uint length = (uint)ptrBuf.Length;
            try
            {
                uint lpRegKeyType;
                int result = RegQueryValueEx(hDeviceRegistryKey, "PortName", 0, out lpRegKeyType, ptrBuf, ref length);
                if (result != 0)
                {
                    throw new Exception("Can not read registry value PortName for device " + deviceInfoData.ClassGuid);
                }
            }
            finally
            {
                RegCloseKey(hDeviceRegistryKey);
            }

            return Encoding.Unicode.GetString(ptrBuf, 0, (int)length - utf16terminatorSize_bytes);
        }

        private static string GetDeviceDescription(IntPtr hDeviceInfoSet, SP_DEVINFO_DATA deviceInfoData)
        {
            byte[] ptrBuf = new byte[BUFFER_SIZE];
            uint propRegDataType;
            uint RequiredSize;
            bool success = SetupDiGetDeviceRegistryProperty(hDeviceInfoSet, ref deviceInfoData, SPDRP.SPDRP_DEVICEDESC,
                out propRegDataType, ptrBuf, BUFFER_SIZE, out RequiredSize);
            if (!success)
            {
                throw new Exception("Can not read registry value PortName for device " + deviceInfoData.ClassGuid);
            }
            return Encoding.Unicode.GetString(ptrBuf, 0, (int)RequiredSize - utf16terminatorSize_bytes);
        }

        private static string GetDeviceBusDescription(IntPtr hDeviceInfoSet, SP_DEVINFO_DATA deviceInfoData)
        {
            byte[] ptrBuf = new byte[BUFFER_SIZE];
            uint propRegDataType;
            uint RequiredSize;
            bool success = SetupDiGetDevicePropertyW(hDeviceInfoSet, ref deviceInfoData, ref DEVPKEY_Device_BusReportedDeviceDesc,
                out propRegDataType, ptrBuf, BUFFER_SIZE, out RequiredSize, 0);
            if (!success)
            {
                throw new Exception("Can not read Bus provided device description device " + deviceInfoData.ClassGuid);
            }
            return System.Text.UnicodeEncoding.Unicode.GetString(ptrBuf, 0, (int)RequiredSize - utf16terminatorSize_bytes);
        }

        private static Guid[] GetClassGUIDs(string className)
        {
            UInt32 requiredSize = 0;
            Guid[] guidArray = new Guid[1];

            bool status = SetupDiClassGuidsFromName(className, ref guidArray[0], 1, out requiredSize);
            if (true == status)
            {
                if (1 < requiredSize)
                {
                    guidArray = new Guid[requiredSize];
                    SetupDiClassGuidsFromName(className, ref guidArray[0], requiredSize, out requiredSize);
                }
            }
            else
                throw new System.ComponentModel.Win32Exception();

            return guidArray;
        }
    }
}

Answer 2

To go off of vromanov's code. All you have to do is the following to get the bus description of each com port, where 0 is the First Com, 1 would be the second, and so on.

Console.WriteLine(Win32DeviceMgmt.GetAllCOMPorts()[0].bus_description);

Answer 3

I know this is a bit off-topic, because it's not C#, but for the case someone was also looking for just any solution to get the "bus reported device description" programmatically, like I was (in my case a USB ethernet device) and stumbles upon this question, here is my PowerShell solution based on what I could collect from different sources after searching for some hours!:

(Get-WMIObject Win32_PnPEntity | where {$_.name -match "ethernet"}).GetDeviceProperties("DEVPKEY_Device_BusReportedDeviceDesc").DeviceProperties.Data

Theoretically speaking, you could use this as a system process in your C# code, but it's a weird method. You might also be able to work directly with WmiObjects somehow, but I have no experience with it in C#.

Answer 4

I wanted to add a different method. maybe it will be needed. vb.net code:

Imports System.Runtime.InteropServices

Public Class Form1

    Dim DEVPKEY_Device_DeviceDesc As DEVPROPKEY
    Dim DEVPKEY_Device_FriendlyName As DEVPROPKEY
    Dim DEVPKEY_Device_BusReportedDeviceDesc As DEVPROPKEY

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click

        'a5dcbf10-6530-11d2-901f-00c04fb951ed
        Dim hidGuid As New Guid("a5dcbf10-6530-11d2-901f-00c04fb951ed") 'USB_VID VE CİHAZ SERİ NO ALIR
        DEVPKEY_Device_DeviceDesc = New DEVPROPKEY()
        DEVPKEY_Device_DeviceDesc.fmtid = New Guid("A45C254E-DF1C-4EFD-8020-67D146A850E0")
        DEVPKEY_Device_DeviceDesc.pid = 2

        DEVPKEY_Device_FriendlyName = New DEVPROPKEY()
        DEVPKEY_Device_FriendlyName.fmtid = New Guid("A45C254E-DF1C-4EFD-8020-67D146A850E0")
        DEVPKEY_Device_FriendlyName.pid = 14

        DEVPKEY_Device_BusReportedDeviceDesc = New DEVPROPKEY()
        DEVPKEY_Device_BusReportedDeviceDesc.fmtid = New Guid("540B947E-8B40-45BC-A8A2-6A0B894CBDA2")
        DEVPKEY_Device_BusReportedDeviceDesc.pid = 4

        Dim GUID_DEVINTERFACE_USB_DEVICE As New Guid("A5DCBF10-6530-11D2-901F-00C04FB951ED")
        Dim GUID_DEVINTERFACE_USB_HOST_CONTROLLER As New Guid("3ABF6F2D-71C4-462a-8A92-1E6861E6AF27")
        Dim GUID_DEVINTERFACE_USB_HUB As New Guid("f18a0e88-c30c-11d0-8815-00a0c906bed8")
        'Dim GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR As New Guid("4D36E978-E325-11CE-BFC1-08002BE10318")
        Dim GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR As New Guid("A5DCBF10-6530-11D2-901F-00C04FB951ED")

        Dim sGuid As Guid = GUID_DEVINTERFACE_SERENUM_BUS_ENUMERATOR
        Dim hdevDisplayInfoSet As IntPtr = SetupDiGetClassDevs(sGuid, IntPtr.Zero, IntPtr.Zero, DIGCF_PRESENT Or DIGCF_DEVICEINTERFACE)
        If (hdevDisplayInfoSet <> IntPtr.Zero) Then
            Dim data As SP_DEVICE_INTERFACE_DATA = New SP_DEVICE_INTERFACE_DATA()
            Dim nStatus As Integer = 0
            Dim i As Integer = 0
            Dim b As Boolean = False
            While (nStatus = 0)
                data.cbSize = Marshal.SizeOf(GetType(SP_DEVICE_INTERFACE_DATA))
                b = SetupDiEnumDeviceInterfaces(hdevDisplayInfoSet, IntPtr.Zero, sGuid, i, data)
                If (Not b) Then
                    nStatus = Marshal.GetLastWin32Error()
                    Exit While
                End If
                Dim dwBytes As UInteger = 0
                Dim bRet As Boolean = SetupDiGetDeviceInterfaceDetail(hdevDisplayInfoSet, data, IntPtr.Zero, 0, dwBytes, IntPtr.Zero)
                nStatus = Marshal.GetLastWin32Error()
                If (Not bRet And Marshal.GetLastWin32Error() = ERROR_INSUFFICIENT_BUFFER) Then
                    Dim didd As SP_DEVICE_INTERFACE_DETAIL_DATA = New SP_DEVICE_INTERFACE_DETAIL_DATA()
                    Dim nSize = 4 + If(IntPtr.Size = 4, 2, 4)
                    didd.cbSize = nSize
                    Dim da As SP_DEVINFO_DATA = New SP_DEVINFO_DATA()
                    da.cbSize = Marshal.SizeOf(da)
                    bRet = SetupDiGetDeviceInterfaceDetail(hdevDisplayInfoSet, data, didd, dwBytes, dwBytes, da)
                    If (bRet) Then
                        Console.WriteLine("Device Path: {0}", didd.DevicePath)
                        TextBox1.Text = didd.DevicePath
                        ListBox1.Items.Add(didd.DevicePath)
                        'ListBox1.Items.Add(description)
                        Dim nRequiredSize As UInteger = 0
                        Dim nCharSize As Integer = 260 * Marshal.SystemDefaultCharSize
                        Dim pBuffer As IntPtr = Marshal.AllocHGlobal(nCharSize)
                        Dim nPropertyType As UInteger = 0
                        bRet = SetupDiGetDeviceProperty(hdevDisplayInfoSet, da, DEVPKEY_Device_DeviceDesc, nPropertyType, pBuffer, nCharSize, nRequiredSize, 0)
                        If (bRet <> 0) Then
                            Dim sDeviceDesc As String = Marshal.PtrToStringUni(pBuffer)
                            Console.WriteLine("Description : {0}", sDeviceDesc)
                            TextBox2.Text = sDeviceDesc
                            ListBox2.Items.Add(sDeviceDesc)
                        Else
                            Dim nError As Integer = Marshal.GetLastWin32Error()
                        End If
                        Marshal.FreeHGlobal(pBuffer)

                        pBuffer = Marshal.AllocHGlobal(nCharSize)
                        bRet = SetupDiGetDeviceProperty(hdevDisplayInfoSet, da, DEVPKEY_Device_BusReportedDeviceDesc, nPropertyType, pBuffer, nCharSize, nRequiredSize, 0)
                        If (bRet <> 0) Then
                            Dim sReportedDeviceDesc As String = Marshal.PtrToStringUni(pBuffer)
                            Console.WriteLine("Reported Device Desc : {0}", sReportedDeviceDesc)
                            TextBox3.Text = sReportedDeviceDesc
                            ListBox3.Items.Add(sReportedDeviceDesc)
                        Else
                            'ERROR_NOT_FOUND  1168(0x490)
                            Dim nError As Integer = Marshal.GetLastWin32Error()
                        End If
                        Marshal.FreeHGlobal(pBuffer)

                        nStatus = 0
                        Console.WriteLine("")
                        TextBox4.Text = ""

                    End If
                End If
                i += 1
            End While
            SetupDiDestroyDeviceInfoList(hdevDisplayInfoSet)
        End If
    End Sub

    <DllImport("Setupapi.dll", CharSet:=CharSet.Unicode, SetLastError:=True)>
    Public Shared Function SetupDiGetClassDevs(ByRef ClassGuid As Guid, ByVal Enumerator As IntPtr, ByVal hWndParent As IntPtr, ByVal Flags As Integer) As IntPtr
    End Function

    <DllImport("Setupapi.dll", CharSet:=CharSet.Unicode, SetLastError:=True)>
    Private Shared Function SetupDiEnumDeviceInterfaces(ByVal DeviceInfoSet As IntPtr, ByVal DeviceInfoData As IntPtr, ByRef InterfaceClassGuid As Guid, ByVal MemberIndex As Integer, ByRef DeviceInterfaceData As SP_DEVICE_INTERFACE_DATA) As Boolean
    End Function

    <DllImport("Setupapi.dll", CharSet:=CharSet.Unicode, SetLastError:=True)>
    Public Shared Function SetupDiDestroyDeviceInfoList(ByVal DeviceInfoSet As IntPtr) As Boolean
    End Function

    <DllImport("Setupapi.dll", CharSet:=CharSet.Unicode, SetLastError:=True)>
    Public Shared Function SetupDiGetDeviceProperty(ByVal deviceInfoSet As IntPtr, <[In]> ByRef DeviceInfoData As SP_DEVINFO_DATA, <[In]> ByRef propertyKey As DEVPROPKEY, <Out> ByRef propertyType As UInteger, ByVal propertyBuffer As IntPtr, ByVal propertyBufferSize As UInteger, <Out> ByRef requiredSize As UInteger, ByVal flags As UInteger) As Boolean
    End Function

    <StructLayout(LayoutKind.Sequential)>
    Public Structure DEVPROPKEY
        Public fmtid As Guid
        Public pid As UInteger
    End Structure

    <DllImport("Setupapi.dll", CharSet:=CharSet.Unicode, SetLastError:=True)>
    Public Shared Function SetupDiGetDeviceInterfaceDetail(ByVal hDevInfo As IntPtr, ByRef deviceInterfaceData As SP_DEVICE_INTERFACE_DATA, ByVal deviceInterfaceDetailData As IntPtr, ByVal deviceInterfaceDetailDataSize As UInt32, <System.Runtime.InteropServices.Out()> ByRef requiredSize As UInt32, ByVal deviceInfoData As IntPtr) As Boolean
    End Function

    <DllImport("Setupapi.dll", CharSet:=CharSet.Unicode, SetLastError:=True)>
    Public Shared Function SetupDiGetDeviceInterfaceDetail(ByVal hDevInfo As IntPtr, ByRef deviceInterfaceData As SP_DEVICE_INTERFACE_DATA, ByRef deviceInterfaceDetailData As SP_DEVICE_INTERFACE_DETAIL_DATA, ByVal deviceInterfaceDetailDataSize As UInt32, <System.Runtime.InteropServices.Out()> ByRef requiredSize As UInt32, ByRef deviceInfoData As SP_DEVINFO_DATA) As Boolean
    End Function

    Public Const DIGCF_PRESENT As Integer = &H2
    Public Const DIGCF_DEVICEINTERFACE As Integer = &H10
    Public Const ERROR_INSUFFICIENT_BUFFER As Integer = 122

    <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
    Public Structure SP_DEVINFO_DATA
        Public cbSize As Integer
        Public ClassGuid As Guid
        Public DevInst As Integer
        Public Reserved As IntPtr
    End Structure

    <StructLayout(LayoutKind.Sequential)>
    Structure SP_DEVICE_INTERFACE_DATA
        Public cbSize As Integer
        Public InterfaceClassGuid As Guid
        Public Flags As Integer
        Public Reserved As IntPtr
    End Structure

    <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode, Pack:=1)>
    Structure SP_DEVICE_INTERFACE_DETAIL_DATA
        Public cbSize As Integer
        <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=260)>
        Public DevicePath As String
    End Structure

End Class

Answer 5

string description = (string)device.GetPropertyValue("Description");