private static extern Boolean SetupDiEnumDeviceInterfaces(
     IntPtr hDevInfo,
     ref SP_DEVINFO_DATA devInfo,
     ref Guid interfaceClassGuid,
     UInt32 memberIndex,
     ref SP_DEVICE_INTERFACE_DATA deviceInterfaceData
     );

        private static IEnumerable<SP_DEVICE_INTERFACE_DATA> SetupDiEnumDeviceInterfacesHelper(
            SafeDeviceInfoSetHandle lpDeviceInfoSet,
            SP_DEVINFO_DATA? deviceInfoData,
            Guid interfaceClassGuid)
        {
            int index = 0;
            while (true)
            {
                var data = SP_DEVICE_INTERFACE_DATA.Create();

                bool result = SetupDiEnumDeviceInterfaces(
                    lpDeviceInfoSet,
                    deviceInfoData,
                    ref interfaceClassGuid,
                    index,
                    ref data);

                if (!result)
                {
                    var lastError = GetLastError();
                    if (lastError != Win32ErrorCode.ERROR_NO_MORE_ITEMS)
                    {
                        throw new Win32Exception(lastError);
                    }

                    yield break;
                }

                yield return data;
                index++;
            }
        }

 public static extern IntPtr SetupDiOpenDevRegKey(
     IntPtr hDeviceInfoSet,
     ref SP_DEVINFO_DATA deviceInfoData,
     int scope,
     int hwProfile,
     int parameterRegistryValueKind,
     int samDesired);

        static void Main(string[] args)
        {
            int deviceCount = 0;
            IntPtr deviceList = IntPtr.Zero;
            // GUID for processor classid
            Guid processorGuid = new Guid("{50127dc3-0f36-415e-a6cc-4cb3be910b65}");

            try
            {
                // get a list of all processor devices
                deviceList = SetupDiGetClassDevs(ref processorGuid, "ACPI", IntPtr.Zero, (int)DIGCF.PRESENT);
                // attempt to process each item in the list
                for (int deviceNumber = 0; ; deviceNumber++)
                {
                    SP_DEVINFO_DATA deviceInfo = new SP_DEVINFO_DATA();
                    deviceInfo.cbSize = Marshal.SizeOf(deviceInfo);

                    // attempt to read the device info from the list, if this fails, we're at the end of the list
                    if (!SetupDiEnumDeviceInfo(deviceList, deviceNumber, ref deviceInfo))
                    {
                        deviceCount = deviceNumber - 1;
                        break;
                    }
                }
            }
            finally
            {
                if (deviceList != IntPtr.Zero) { SetupDiDestroyDeviceInfoList(deviceList); }
            }
            Console.WriteLine("Number of cores: {0}{1}{2}{3}", Environment.MachineName, Environment.ExitCode, Environment.CurrentDirectory,Environment.SystemDirectory);
        }

 public DeviceInfo(DeviceEnumerator deviceEnumerator, SP_DEVINFO_DATA devinfoData, string devicePath, string deviceID, string userFriendlyName)
 {
     this.deviceEnumerator = deviceEnumerator;
     this.devinfoData = devinfoData;
     DevicePath = devicePath;
     DeviceID = deviceID;
     UserFriendlyName = userFriendlyName;
 }

 static extern Boolean SetupDiGetDeviceInterfaceDetail(
    IntPtr hDevInfo,
    ref SP_DEVICE_INTERFACE_DATA deviceInterfaceData,
    ref SP_DEVICE_INTERFACE_DETAIL_DATA deviceInterfaceDetailData,
    UInt32 deviceInterfaceDetailDataSize,
    out UInt32 requiredSize,
    ref SP_DEVINFO_DATA deviceInfoData
 );

		  SetupDiGetDeviceRegistryPropertyA(
				IntPtr DeviceInfoSet,
				SP_DEVINFO_DATA	 DeviceInfoData,
				UInt32 Property,
				UInt32   PropertyRegDataType,
				StringBuilder  PropertyBuffer,
				UInt32 PropertyBufferSize,
				IntPtr RequiredSize);

 public static unsafe IEnumerable<SP_DEVICE_INTERFACE_DATA> SetupDiEnumDeviceInterfaces(
     SafeDeviceInfoSetHandle lpDeviceInfoSet,
     SP_DEVINFO_DATA* deviceInfoData,
     Guid interfaceClassGuid)
 {
     // Copy out the value of the struct pointed to (if any) so that
     // the caller does not need to remember to keep the pointer fixed
     // for the entire enumeration.
     var deviceInfoDataCopy = deviceInfoData != null ? (SP_DEVINFO_DATA?)*deviceInfoData : null;
     return SetupDiEnumDeviceInterfacesHelper(
         lpDeviceInfoSet,
         deviceInfoDataCopy,
         interfaceClassGuid);
 }

        /// <summary>
        /// Retrieves a COM Port Name from the friendly name prefix
        /// </summary>
        /// <param name="friendlyNamePrefix">Prefix to search with</param>
        /// <returns></returns>
        public static string ComPortNameFromFriendlyNamePrefix(string friendlyNamePrefix)
        {
            const string className = "Ports";
            Guid[] guids = GetClassGUIDs(className);

            System.Text.RegularExpressions.Regex friendlyNameToComPort =
                new System.Text.RegularExpressions.Regex(@".? \((COM\d+)\)$");  // "..... (COMxxx)" -> COMxxxx

            foreach (Guid guid in guids)
            {
                // We start at the "root" of the device tree and look for all
                // devices that match the interface GUID of a disk
                Guid guidClone = guid;
                IntPtr h = SetupDiGetClassDevs(ref guidClone, IntPtr.Zero, IntPtr.Zero, DIGCF_PRESENT | DIGCF_PROFILE);
                if (h.ToInt32() != INVALID_HANDLE_VALUE)
                {
                    int nDevice = 0;
                    while (true)
                    {
                        SP_DEVINFO_DATA da = new SP_DEVINFO_DATA();
                        da.cbSize = (uint)Marshal.SizeOf(da);

                        if (0 == SetupDiEnumDeviceInfo(h, nDevice++, ref da))
                            break;

                        uint RegType;
                        byte[] ptrBuf = new byte[BUFFER_SIZE];
                        uint RequiredSize;
                        if (SetupDiGetDeviceRegistryProperty(h, ref da,
                            (uint)SPDRP.FRIENDLYNAME, out RegType, ptrBuf,
                            BUFFER_SIZE, out RequiredSize))
                        {
                            const int utf16terminatorSize_bytes = 2;
                            string friendlyName = System.Text.UnicodeEncoding.Unicode.GetString(ptrBuf, 0, (int)RequiredSize - utf16terminatorSize_bytes);

                            if (!friendlyName.StartsWith(friendlyNamePrefix))
                                continue;

                            if (!friendlyNameToComPort.IsMatch(friendlyName))
                                continue;

                            return friendlyNameToComPort.Match(friendlyName).Groups[1].Value;
                        }
                    } // devices
                    SetupDiDestroyDeviceInfoList(h);
                }
            } // class guids

            return null;
        }

 Boolean GetRegProp(IntPtr deviceInfoSet, ref SP_DEVINFO_DATA devInfo, uint property, out string propertyVal)
 {
     uint RequiredSize = 0;
     uint RegType;
     propertyVal = null;
     SetupDiGetDeviceRegistryProperty(deviceInfoSet, ref devInfo, property, out RegType, IntPtr.Zero, 0, out RequiredSize);
     if (RequiredSize > 0)
     {
         IntPtr ptrBuf = Marshal.AllocHGlobal((int)RequiredSize);
         if (SetupDiGetDeviceRegistryProperty(deviceInfoSet, ref devInfo, property, out RegType, ptrBuf, RequiredSize, out RequiredSize))
             propertyVal = Marshal.PtrToStringAuto(ptrBuf);
         Marshal.FreeHGlobal(ptrBuf);
     }
     return propertyVal != null;
 }

 Boolean GetInstanceId(IntPtr deviceInfoSet, ref SP_DEVINFO_DATA devInfo, out string instanceId)
 {
     uint RequiredSize = 256;
     instanceId = null;
     IntPtr ptrBuf = Marshal.AllocHGlobal((int)RequiredSize);
     if (SetupDiGetDeviceInstanceId(deviceInfoSet, ref devInfo, ptrBuf, RequiredSize, out RequiredSize))
         instanceId = Marshal.PtrToStringAuto(ptrBuf);
     else if (RequiredSize > 0)
     {
         Marshal.ReAllocHGlobal(ptrBuf, new IntPtr(RequiredSize));
         if (SetupDiGetDeviceInstanceId(deviceInfoSet, ref devInfo, ptrBuf, RequiredSize, out RequiredSize))
             instanceId = Marshal.PtrToStringAuto(ptrBuf);
     }
     Marshal.FreeHGlobal(ptrBuf);
     return instanceId != null;
 }

        public static unsafe string SetupDiGetDeviceInterfaceDetail(
            SafeDeviceInfoSetHandle deviceInfoSet,
            SP_DEVICE_INTERFACE_DATA interfaceData,
            SP_DEVINFO_DATA* deviceInfoData)
        {
            int requiredSize;

            // First call to get the size to allocate
            SetupDiGetDeviceInterfaceDetail(
                deviceInfoSet,
                ref interfaceData,
                null,
                0,
                &requiredSize,
                deviceInfoData);

            // As we passed an empty buffer we know that the function will fail, not need to check the result.
            var lastError = GetLastError();
            if (lastError != Win32ErrorCode.ERROR_INSUFFICIENT_BUFFER)
            {
                throw new Win32Exception(lastError);
            }

            fixed (byte* pBuffer = new byte[requiredSize])
            {
                var pDetail = (SP_DEVICE_INTERFACE_DETAIL_DATA*)pBuffer;
                pDetail->cbSize = SP_DEVICE_INTERFACE_DETAIL_DATA.ReportableStructSize;

                // Second call to get the value
                var success = SetupDiGetDeviceInterfaceDetail(
                    deviceInfoSet,
                    ref interfaceData,
                    pDetail,
                    requiredSize,
                    null,
                    null);

                if (!success)
                {
                    Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
                    return null;
                }

                return SP_DEVICE_INTERFACE_DETAIL_DATA.GetDevicePath(pDetail);
            }
        }

        public static bool Create(string className, Guid classGuid, string node)
        {
            var deviceInfoSet = (IntPtr)(-1);
            var deviceInfoData = new SP_DEVINFO_DATA();

            try
            {
                deviceInfoSet = SetupDiCreateDeviceInfoList(ref classGuid, IntPtr.Zero);

                if (deviceInfoSet == (IntPtr)(-1))
                {
                    return false;
                }

                deviceInfoData.cbSize = Marshal.SizeOf(deviceInfoData);

                if (
                    !SetupDiCreateDeviceInfo(deviceInfoSet, className, ref classGuid, null, IntPtr.Zero,
                        DICD_GENERATE_ID, ref deviceInfoData))
                {
                    return false;
                }

                if (
                    !SetupDiSetDeviceRegistryProperty(deviceInfoSet, ref deviceInfoData, SPDRP_HARDWAREID, node,
                        node.Length * 2))
                {
                    return false;
                }

                if (!SetupDiCallClassInstaller(DIF_REGISTERDEVICE, deviceInfoSet, ref deviceInfoData))
                {
                    return false;
                }
            }
            finally
            {
                if (deviceInfoSet != (IntPtr)(-1))
                {
                    SetupDiDestroyDeviceInfoList(deviceInfoSet);
                }
            }

            return true;
        }

        public static Guid GuidDevinterfaceUSBDevice = new Guid(GUID_DEVINTERFACE_USB_DEVICE); // USB devices
        #endregion

        /// <summary>
        /// ISBデバイスのDescriptionの一覧を作成する
        /// </summary>
        public static IList<string> MakeDeviceList()
        {
            List<string> list = new List<string>();

            Guid guid = Guid.Empty;
            IntPtr DevInfoHandle = IntPtr.Zero;

            //DevInfoHandle = SetupDiGetClassDevs(
            //                         IntPtr.Zero, null, IntPtr.Zero,
            //                         DIGCF_ALLCLASSES | DIGCF_PRESENT);

            // USBデバイスだけ列挙
            DevInfoHandle = SetupDiGetClassDevs(
                            ref GuidDevinterfaceUSBDevice, IntPtr.Zero, IntPtr.Zero,
                            DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);

            SP_DEVINFO_DATA DevInfoData = new SP_DEVINFO_DATA
            {
                classGuid = Guid.Empty,
                devInst = 0,
                reserved = IntPtr.Zero
            };

            DevInfoData.cbSize = (uint)Marshal.SizeOf(DevInfoData);// 32, // 28 When 32-Bit, 32 When 64-Bit,

            for (uint i = 0; SetupDiEnumDeviceInfo(DevInfoHandle, i, ref DevInfoData); i++)
            {
                string str = GetStringPropertyForDevice(
                    DevInfoHandle,
                    DevInfoData,
                    (uint)SetupDiGetDeviceRegistryPropertyEnum.SPDRP_DEVICEDESC);

                if (str != null)
                    list.Add(str.Replace("\0", ""));
                else
                    str = "(null)";

                // I-O DATA GV-USB2t.gvusb2.name%;I-O DATA GV-USB2
                Debug.WriteLine(str.Replace("\0", ""));
            }
            SetupDiDestroyDeviceInfoList(DevInfoHandle);

            return list;
        }

        public string GetDevicePath(Guid classGuid)
        {
            IntPtr hDevInfo = IntPtr.Zero;
            try
            {
                hDevInfo = SetupDiGetClassDevs(ref classGuid, null, IntPtr.Zero, DiGetClassFlags.DIGCF_DEVICEINTERFACE | DiGetClassFlags.DIGCF_PRESENT);

                if (hDevInfo.ToInt64() <= 0)
                {
                    throw new Win32Exception(Marshal.GetLastWin32Error());
                }

                SP_DEVICE_INTERFACE_DATA dia = new SP_DEVICE_INTERFACE_DATA();
                dia.cbSize = (uint)Marshal.SizeOf(dia);

                SP_DEVINFO_DATA devInfo = new SP_DEVINFO_DATA();
                devInfo.cbSize = (UInt32)Marshal.SizeOf(devInfo);

                UInt32 i = 0;

                // start the enumeration
                if (!SetupDiEnumDeviceInterfaces(hDevInfo, null, ref classGuid, i, dia))
                {
                    throw new Win32Exception(Marshal.GetLastWin32Error());
                }

                SP_DEVICE_INTERFACE_DETAIL_DATA didd = new SP_DEVICE_INTERFACE_DETAIL_DATA();
                didd.cbSize = 4 + Marshal.SystemDefaultCharSize; // trust me :)

                UInt32 requiredSize = 0;

                if (!SetupDiGetDeviceInterfaceDetail(hDevInfo, dia, ref didd, 256, out requiredSize, devInfo))
                {
                    throw new Win32Exception(Marshal.GetLastWin32Error());
                }

                return didd.DevicePath;

            }
            finally
            {
                SetupDiDestroyDeviceInfoList(hDevInfo);
            }
        }

        private static byte[] GetProperty(IntPtr deviceInfoSet, SP_DEVINFO_DATA deviceInfoData, SPDRP property, out int regType)
        {
            uint requiredSize;

            if (!SetupDiGetDeviceRegistryProperty(deviceInfoSet, ref deviceInfoData, property, IntPtr.Zero, IntPtr.Zero, 0, out requiredSize))
            {
                if (Marshal.GetLastWin32Error() != ERROR_INSUFFICIENT_BUFFER)
                    throw APIException.Win32("Failed to get buffer size for device registry property.");
            }

            byte[] buffer = new byte[requiredSize];

            if (!SetupDiGetDeviceRegistryProperty(deviceInfoSet, ref deviceInfoData, property, out regType, buffer, (uint)buffer.Length, out requiredSize))
                throw APIException.Win32("Failed to get device registry property.");

            return buffer;

           
           
        }

        protected static bool DevicePresent(Guid g)
        {
            // Used to capture how many bytes are returned by system calls
            UInt32 theBytesReturned = 0;

            // SetupAPI32.DLL Data Structures
            SP_DEVINFO_DATA theDevInfoData = new SP_DEVINFO_DATA();
            theDevInfoData.cbSize = Marshal.SizeOf(theDevInfoData);
            IntPtr theDevInfo = SetupDiGetClassDevs(ref g, IntPtr.Zero, IntPtr.Zero, (int)(DiGetClassFlags.DIGCF_PRESENT | DiGetClassFlags.DIGCF_DEVICEINTERFACE));
            SP_DEVICE_INTERFACE_DATA theInterfaceData = new SP_DEVICE_INTERFACE_DATA();
            theInterfaceData.cbSize = Marshal.SizeOf(theInterfaceData);

            // Check for the device
            if (!SetupDiEnumDeviceInterfaces(theDevInfo, IntPtr.Zero, ref g, 0, ref theInterfaceData) && GetLastError() == ERROR_NO_MORE_ITEMS)
                return false;

            // Get the device's file path
            SetupDiGetDeviceInterfaceDetail(theDevInfo, ref theInterfaceData, IntPtr.Zero, 0, ref theBytesReturned, IntPtr.Zero);

            return !(theBytesReturned <= 0);
        }

 /// <summary>
 /// Installs a driver using its INF file
 /// </summary>
 /// <param name="filePath">Relative or absolute INF file path</param>
 /// <param name="hardwareID">ComponentID</param>
 /// <returns></returns>
 public static bool InstallInfDriver(string filePath, string hardwareID, string description = "")
 {
     // TODO: Win10 got wrong bitness onetime (???)
     if (IntPtr.Size == 4 && Environment.Is64BitOperatingSystem)
     {
         MessageBox.Show("This process is 32-bit but the OS is 64-bit. Only 64-bit processes can install 64-bit direvers.",
             "Driver Setup", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button2, MessageBoxOptions.ServiceNotification);
         return false;
     }
     filePath = Path.GetFullPath(filePath);
     GUID classGuid = new GUID();
     char[] className = new char[MAX_CLASS_NAME_LEN];
     uint requiredSize = 0;
     SP_DEVINFO_DATA deviceInfoData = new SP_DEVINFO_DATA();
     deviceInfoData.cbSize = (uint)Marshal.SizeOf(deviceInfoData);
     // Use the INF File to extract the Class GUID
     if (!SetupDiGetINFClass(filePath, ref classGuid, className, MAX_CLASS_NAME_LEN, ref requiredSize))
         return false;
     // Create the container for the to-be-created Device Information Element
     IntPtr deviceInfoSet = SetupDiCreateDeviceInfoList(ref classGuid, IntPtr.Zero);
     if (deviceInfoSet == Kernel32.INVALID_HANDLE_VALUE)
         return false;
     // Now create the element. Use the Class GUID and Name from the INF file
     if (!SetupDiCreateDeviceInfo(deviceInfoSet, new string(className), ref classGuid, description, IntPtr.Zero, DICD_GENERATE_ID, ref deviceInfoData))
         return false;
     // Add the HardwareID to the Device's HardwareID property
     if (!SetupDiSetDeviceRegistryProperty(deviceInfoSet, ref deviceInfoData, SPDRP_HARDWAREID, Encoding.Unicode.GetBytes(hardwareID), (uint)Encoding.Unicode.GetByteCount(hardwareID)))
         return false;
     // Transform the registry element into an actual devnode in the PnP HW tree
     if (!SetupDiCallClassInstaller(DI_FUNCTION.DIF_REGISTERDEVICE, deviceInfoSet, ref deviceInfoData))
         return false;
     SetupDiDestroyDeviceInfoList(deviceInfoSet);
     // Update the driver for the device we just created
     if (!Newdev.UpdateDriverForPlugAndPlayDevices(IntPtr.Zero, hardwareID, filePath, Newdev.INSTALLFLAG_FORCE, IntPtr.Zero))
         return false;
     return true;
 }

 private static extern Boolean SetupDiEnumDeviceInfo(IntPtr DeviceInfoSet, UInt32 MemberIndex, ref SP_DEVINFO_DATA DeviceInfoData);

 private static extern Boolean SetupDiGetDeviceInstanceId(
     IntPtr DeviceInfoSet,
     ref SP_DEVINFO_DATA DeviceInfoData,
     StringBuilder DeviceInstanceId,
     Int32 DeviceInstanceIdSize,
     IntPtr RequiredSize
     );