Win32 Wmi获取设备信息

已于 2024-09-20 21:34:10 修改
阅读量558 收藏
点赞数 3
CC 4.0 BY-SA版权
分类专栏： C++ Win32 WMI 文章标签： C++ Win32 硬件信息获取
于 2024-09-19 21:33:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Flame_Cyclone/article/details/142370339

CDeviceHelper.h

#pragma once
#include <windows.h>
#include <string>
#include "CWmiQueryHelper.h"
#include <stdint.h>

#ifdef _UNICODE
using _tstring = std::wstring;
#else
using _tstring = std::string;
#endif

// 设备主板信息
using DEVICE_BASEBOARD_INFO = struct
{
    _tstring BaseBoardManufacturer;     //主板制造商
    _tstring BaseBoardProduct;          //主板产品
    _tstring BaseBoardVersion;          //主板版本
};

// 设备BIOS信息
using DEVICE_BIOS_INFO = struct
{
    _tstring Manufacturer;              //制造商
    _tstring BIOSVersion;               //版本
    _tstring SerialNumber;              //序列号
    struct {
        uint16_t nYear;
        uint16_t nMonth;
        uint16_t nDay;
        uint16_t nHour;
        uint16_t nMinute;
        uint16_t nSecond;
    }BIOSReleaseDate;                   //发布日期
    int BiosMajorRelease;               //主版本号
    int BiosMinorRelease;               //子版本号
    int ECFirmwareMajorRelease;         //EC主版本号
    int ECFirmwareMinorRelease;         //EC子版本号
};

// 设备系统信息
using DEVICE_SYSTEM_INFO = struct
{
    _tstring    SystemFamily;           // 家族
    _tstring    SystemManufacturer;     // 制造商
    _tstring    SystemProductName;      // 产品名
    _tstring    SystemSKU;              // SKU
    _tstring    SystemVersion;          // 系统版本
};

// CPU信息
using DEVICE_CPU_INFO = struct
{
    _tstring Name;                      // CPU名
    uint32_t MaxClockSpeed;             // 主频速度
    uint32_t NumberOfCores;             // 物理核心数量
    uint32_t ThreadCount;               // 线程数量
};

// 物理内存
using DEVICE_PHYSICAL_MEMORY_ITEM = struct
{
    _tstring BankLabel;
    _tstring Caption;
    _tstring CreationClassName;
    _tstring Description;
    _tstring DeviceLocator;
    _tstring Manufacturer;
    _tstring Tag;
    _tstring Name;
    _tstring PartNumber;
    _tstring SerialNumber;
    uint64_t Capacity;
    uint32_t Attributes;
    uint32_t ConfiguredClockSpeed;
    uint32_t ConfiguredVoltage;
    uint32_t DataWidth;
    uint32_t FormFactor;
    uint32_t MaxVoltage;
    uint32_t MemoryType;
    uint32_t MinVoltage;
    uint32_t SMBIOSMemoryType;
    uint32_t Speed;
    uint32_t TotalWidth;
    uint32_t TypeDetail;
    _tstring Status;
    _tstring Version;
    _tstring SKU;
    _tstring Model;
    _tstring OtherIdentifyingInfo;
};

// 物理内存
using DEVICE_PHYSICAL_MEMORY_INFO = struct
{
    std::vector<DEVICE_PHYSICAL_MEMORY_ITEM> Items;        // 内存
    uint64_t Capacity;                                     // 内存容量
};

// 视频控制器
using DEVICE_VIDEO_CONTROLLER_ITEM = struct
{
    _tstring Description;
    _tstring AdapterCompatibility;
    _tstring AdapterDACType;
    _tstring DeviceID;
    _tstring DriverVersion;
    _tstring InstalledDisplayDrivers;
    _tstring Name;
    _tstring PNPDeviceID;
    _tstring VideoModeDescription;
    _tstring VideoProcessor;
    uint64_t AdapterRAM;
    uint64_t CurrentNumberOfColors;
    uint32_t CurrentBitsPerPixel;
    uint32_t CurrentHorizontalResolution;
    uint32_t CurrentNumberOfColumns;
    uint32_t CurrentNumberOfRows;
    uint32_t CurrentRefreshRate;
    uint32_t CurrentScanMode;
    uint32_t CurrentVerticalResolution;
    uint32_t MaxRefreshRate;
    uint32_t MinRefreshRate;
    uint16_t VideoArchitecture;
    uint16_t VideoMemoryType;
    uint16_t Availability;
};

// 视频控制器
using DEVICE_VIDEO_CONTROLLER_INFO = struct
{
    std::vector<DEVICE_VIDEO_CONTROLLER_ITEM> Items;        // 内存
};

// 设备信息
using DEVICE_INFO = struct
{
    DEVICE_BASEBOARD_INFO Baseboard;                        // 主板
    DEVICE_BIOS_INFO Bios;                                  // BIOS
    DEVICE_SYSTEM_INFO System;                              // 系统
    DEVICE_CPU_INFO Cpu;                                    // CPU
    DEVICE_PHYSICAL_MEMORY_INFO Memory;                     // 内存
    DEVICE_VIDEO_CONTROLLER_INFO VideoController;           // 视频控制器
};

class CDeviceHelper
{
public:

    CDeviceHelper();
    virtual ~CDeviceHelper();

    // 初始化
    bool Initialize();

    // 反初始化
    void Uninitialize();

    DEVICE_INFO GetDeviceInfo();
    DEVICE_BASEBOARD_INFO GetBaseBoardInfo();
    DEVICE_BIOS_INFO GetBiosInfo();
    DEVICE_CPU_INFO GetCpuInfo();
    DEVICE_SYSTEM_INFO GetSystemInfo();
    DEVICE_PHYSICAL_MEMORY_INFO GetPhysicalMemoryInfos();
    DEVICE_VIDEO_CONTROLLER_INFO GetVideoControllerInfos();

private:
    CWmiQueryHelper m_Query;
};

CDeviceHelper.cpp

#include "CDeviceHelper.h"
#include <intrin.h>
#include <powerbase.h>
#include <time.h>

#pragma comment(lib, "PowrProf.lib")

static std::string _WStrToMultiStr(UINT CodePage, const std::wstring& str)
{
    int cbMultiByte = ::WideCharToMultiByte(CodePage, 0, str.c_str(), -1, NULL, 0, NULL, NULL);
    std::string strResult(cbMultiByte, 0);
    size_t nConverted = ::WideCharToMultiByte(CodePage, 0, str.c_str(), (int)str.size(), &strResult[0], (int)strResult.size(), NULL, NULL);
    strResult.resize(nConverted);
    return strResult;
}

static std::wstring _MultiStrToWStr(UINT CodePage, const std::string& str)
{
    int cchWideChar = ::MultiByteToWideChar(CodePage, 0, str.c_str(), -1, NULL, 0);
    std::wstring strResult(cchWideChar, 0);
    size_t nConverted = ::MultiByteToWideChar(CodePage, 0, str.c_str(), (int)str.size(), &strResult[0], (int)strResult.size());
    strResult.resize(nConverted);
    return strResult;
}

static std::wstring TStrToWStr(const _tstring& str)
{
#ifdef _UNICODE
    return str;
#else
    return _MultiStrToWStr(CP_ACP, str);
#endif
}

static std::string TStrToAStr(const _tstring& str)
{
#ifdef _UNICODE
    return _WStrToMultiStr(CP_ACP, str);
#else
    return str;
#endif
}

static _tstring WStrToTStr(const std::wstring& str)
{
#ifdef _UNICODE
    return str;
#else
    return _WStrToMultiStr(CP_ACP, str);
#endif
}

static _tstring AStrToTStr(const std::string& str)
{
#ifdef _UNICODE
    return _MultiStrToWStr(CP_ACP, str);
#else
    return str;
#endif
}

CDeviceHelper::CDeviceHelper()
{

}

CDeviceHelper::~CDeviceHelper()
{
    Uninitialize();
}

bool CDeviceHelper::Initialize()
{
    if (!m_Query.Initialize())
    {
        return false;
    }

    return true;
}

void CDeviceHelper::Uninitialize()
{
    m_Query.Uninitialize();
}

_tstring GetCpuName()
{
    std::string cpuName;
    int cpuInfo[4] = { 0 };
    __cpuid(cpuInfo, 0x80000000);
    unsigned int extMaxCpuID = cpuInfo[0];
    if (extMaxCpuID >= 0x80000004)
    {
        char cpuBrand[0x40] = { 0 };
        for (unsigned int i = 0x80000002; i <= 0x80000004; ++i)
        {
            __cpuid(cpuInfo, i);
            memcpy(cpuBrand + (i - 0x80000002) * 16, cpuInfo, sizeof(cpuInfo));
        }

        // 去除末尾空格
        for (int i = _countof(cpuBrand) - 1; i >=0; i--)
        {
            if (!(' ' == cpuBrand[i] || '\0' == cpuBrand[i]))
            {
                break;
            }

            cpuBrand[i] = '\0';
        }

        cpuName = cpuBrand;
    }

    return AStrToTStr(cpuName);
}

DEVICE_BASEBOARD_INFO CDeviceHelper::GetBaseBoardInfo()
{
    DEVICE_BASEBOARD_INFO infoResult;

    m_Query.ExecQuery(_T("SELECT * FROM Win32_BaseBoard"),
        [&infoResult](uint64_t nIndex,
            const CWmiClassHelper& obj) ->void {

                infoResult.BaseBoardManufacturer = obj.GetString(_T("Manufacturer"));
                infoResult.BaseBoardProduct = obj.GetString(_T("Product"));
                infoResult.BaseBoardVersion = obj.GetString(_T("Version"));

        });

    return infoResult;
}

DEVICE_BIOS_INFO CDeviceHelper::GetBiosInfo()
{
    DEVICE_BIOS_INFO infoResult;
    infoResult.ECFirmwareMajorRelease = 0;
    infoResult.ECFirmwareMinorRelease = 0;
    infoResult.BIOSReleaseDate.nYear = 0;
    infoResult.BIOSReleaseDate.nMonth = 0;
    infoResult.BIOSReleaseDate.nDay = 0;
    infoResult.BIOSReleaseDate.nHour = 0;
    infoResult.BIOSReleaseDate.nMinute = 0;
    infoResult.BIOSReleaseDate.nSecond = 0;
    infoResult.BiosMajorRelease = 0;
    infoResult.BiosMinorRelease = 0;

    m_Query.ExecQuery(_T("SELECT * FROM Win32_BIOS"),
        [&infoResult](uint64_t nIndex,
            const CWmiClassHelper& obj) ->void {

                _tstring strReleaseDate = obj.GetString(_T("ReleaseDate"));
                _stscanf_s(strReleaseDate.c_str(), _T("%4hd%2hd%2hd%2hd%2hd%2hd"), 
                    &infoResult.BIOSReleaseDate.nYear, 
                    &infoResult.BIOSReleaseDate.nMonth, 
                    &infoResult.BIOSReleaseDate.nDay, 
                    &infoResult.BIOSReleaseDate.nHour,
                    &infoResult.BIOSReleaseDate.nMinute, 
                    &infoResult.BIOSReleaseDate.nSecond
                );

                infoResult.Manufacturer = obj.GetString(_T("Manufacturer"));
                infoResult.SerialNumber = obj.GetString(_T("SerialNumber"));
                infoResult.BIOSVersion = obj.GetString(_T("SMBIOSBIOSVersion"));
                infoResult.BiosMajorRelease = obj.GetUInt8(_T("SystemBiosMajorVersion"));
                infoResult.BiosMinorRelease = obj.GetUInt8(_T("SystemBiosMinorVersion"));
                infoResult.ECFirmwareMajorRelease = obj.GetUInt8(_T("EmbeddedControllerMajorVersion"));
                infoResult.ECFirmwareMinorRelease = obj.GetUInt8(_T("EmbeddedControllerMinorVersion"));
        });

    return infoResult;
}

DEVICE_SYSTEM_INFO CDeviceHelper::GetSystemInfo()
{
    DEVICE_SYSTEM_INFO infoResult;

    m_Query.ExecQuery(_T("SELECT SystemFamily,Manufacturer,SystemSKUNumber FROM Win32_ComputerSystem"),
        [&infoResult](uint64_t nIndex,
            const CWmiClassHelper& obj) ->void {

                infoResult.SystemFamily = obj.GetString(_T("SystemFamily"));
                infoResult.SystemManufacturer = obj.GetString(_T("Manufacturer"));
                infoResult.SystemSKU = obj.GetString(_T("SystemSKUNumber"));
        });

    m_Query.ExecQuery(_T("SELECT Name,Version FROM Win32_ComputerSystemProduct"),
        [&infoResult](uint64_t nIndex,
            const CWmiClassHelper& obj) ->void {

                infoResult.SystemProductName = obj.GetString(_T("Name"));
                infoResult.SystemVersion = obj.GetString(_T("Version"));
        });

    return infoResult;
}

DEVICE_CPU_INFO CDeviceHelper::GetCpuInfo()
{
    DEVICE_CPU_INFO infoResult;
    infoResult.NumberOfCores = 0;
    infoResult.ThreadCount = 0;
    infoResult.MaxClockSpeed = 0;

    m_Query.ExecQuery(_T("SELECT Name,MaxClockSpeed,NumberOfCores,ThreadCount FROM Win32_Processor"),
        [&infoResult](uint64_t nIndex,
            const CWmiClassHelper& obj) ->void {

                infoResult.Name = obj.GetString(_T("Name"));
                infoResult.MaxClockSpeed = obj.GetUIntEx(_T("MaxClockSpeed"));
                infoResult.NumberOfCores = obj.GetUIntEx(_T("NumberOfCores"));
                infoResult.ThreadCount   = obj.GetUIntEx(_T("ThreadCount"));

        });

    size_t nSize = infoResult.Name.size();
    for (auto it = infoResult.Name.rbegin(); it != infoResult.Name.rend(); it++)
    {
        if (*it != _T(' '))
        {
            break;
        }
        nSize--;
    }

    infoResult.Name.resize(nSize);

    return infoResult;
}

DEVICE_PHYSICAL_MEMORY_INFO CDeviceHelper::GetPhysicalMemoryInfos()
{
    DEVICE_PHYSICAL_MEMORY_INFO infoResult;
    infoResult.Capacity = 0;

    m_Query.ExecQuery(_T("SELECT * FROM Win32_PhysicalMemory"),
        [&infoResult](uint64_t nIndex,
            const CWmiClassHelper& obj) ->void {

                DEVICE_PHYSICAL_MEMORY_ITEM info;

                info.Attributes             = obj.GetUIntEx(_T("Attributes"));
                info.BankLabel              = obj.GetString(_T("BankLabel"));
                info.Capacity               = obj.GetUIntEx(_T("Capacity"));
                info.Caption                = obj.GetString(_T("Caption"));
                info.ConfiguredClockSpeed   = obj.GetUIntEx(_T("ConfiguredClockSpeed"));
                info.ConfiguredVoltage      = obj.GetUIntEx(_T("ConfiguredVoltage"));
                info.CreationClassName      = obj.GetString(_T("CreationClassName"));
                info.DataWidth              = obj.GetUIntEx(_T("DataWidth"));
                info.Description            = obj.GetString(_T("Description"));
                info.DeviceLocator          = obj.GetString(_T("DeviceLocator"));
                info.FormFactor             = obj.GetUIntEx(_T("FormFactor"));
                info.Manufacturer           = obj.GetString(_T("Manufacturer"));
                info.MaxVoltage             = obj.GetUIntEx(_T("MaxVoltage"));
                info.MemoryType             = obj.GetUIntEx(_T("MemoryType"));
                info.MinVoltage             = obj.GetUIntEx(_T("MinVoltage"));
                info.Name                   = obj.GetString(_T("Name"));
                info.PartNumber             = obj.GetString(_T("PartNumber"));
                info.SerialNumber           = obj.GetString(_T("SerialNumber"));
                info.SMBIOSMemoryType       = obj.GetUIntEx(_T("SMBIOSMemoryType"));
                info.Speed                  = obj.GetUIntEx(_T("Speed"));
                info.Tag                    = obj.GetString(_T("Tag"));
                info.TotalWidth             = obj.GetUIntEx(_T("TotalWidth"));
                info.TypeDetail             = obj.GetUIntEx(_T("TypeDetail"));
                info.Version                = obj.GetString(_T("Version"));
                info.Status                 = obj.GetString(_T("Status"));
                info.SKU                    = obj.GetString(_T("SKU"));
                info.Model                  = obj.GetString(_T("Model"));
                info.OtherIdentifyingInfo   = obj.GetString(_T("OtherIdentifyingInfo"));

                infoResult.Items.push_back(info);

                infoResult.Capacity += info.Capacity;
        });

    return infoResult;
}

DEVICE_VIDEO_CONTROLLER_INFO CDeviceHelper::GetVideoControllerInfos()
{
    DEVICE_VIDEO_CONTROLLER_INFO infoResult;

    m_Query.ExecQuery(_T("SELECT * FROM Win32_VideoController"),
        [&infoResult](uint64_t nIndex,
            const CWmiClassHelper& obj) ->void {

                DEVICE_VIDEO_CONTROLLER_ITEM info;

                info.Description                    =   obj.GetString(_T("Description"));
                info.AdapterCompatibility           =   obj.GetString(_T("AdapterCompatibility"));
                info.AdapterDACType                 =   obj.GetString(_T("AdapterDACType"));
                info.DeviceID                       =   obj.GetString(_T("DeviceID"));
                info.DriverVersion                  =   obj.GetString(_T("DriverVersion"));
                info.InstalledDisplayDrivers        =   obj.GetString(_T("InstalledDisplayDrivers"));
                info.Name                           =   obj.GetString(_T("Name"));
                info.PNPDeviceID                    =   obj.GetString(_T("PNPDeviceID"));
                info.VideoModeDescription           =   obj.GetString(_T("VideoModeDescription"));
                info.VideoProcessor                 =   obj.GetString(_T("VideoProcessor"));
                info.AdapterRAM                     =   obj.GetUIntEx(_T("AdapterRAM"));
                info.CurrentNumberOfColors          =   obj.GetUIntEx(_T("CurrentNumberOfColors"));
                info.CurrentBitsPerPixel            =   obj.GetUIntEx(_T("CurrentBitsPerPixel"));
                info.CurrentHorizontalResolution    =   obj.GetUIntEx(_T("CurrentHorizontalResolution"));
                info.CurrentNumberOfColumns         =   obj.GetUIntEx(_T("CurrentNumberOfColumns"));
                info.CurrentNumberOfRows            =   obj.GetUIntEx(_T("CurrentNumberOfRows"));
                info.CurrentRefreshRate             =   obj.GetUIntEx(_T("CurrentRefreshRate"));
                info.CurrentScanMode                =   obj.GetUIntEx(_T("CurrentScanMode"));
                info.CurrentVerticalResolution      =   obj.GetUIntEx(_T("CurrentVerticalResolution"));
                info.MaxRefreshRate                 =   obj.GetUIntEx(_T("MaxRefreshRate"));
                info.MinRefreshRate                 =   obj.GetUIntEx(_T("MinRefreshRate"));
                info.VideoArchitecture              =   obj.GetUIntEx(_T("VideoArchitecture"));
                info.VideoMemoryType                =   obj.GetUIntEx(_T("VideoMemoryType"));
                info.Availability                   =   obj.GetUIntEx(_T("Availability"));

                infoResult.Items.push_back(info);
        });

    return infoResult;
}

DEVICE_INFO CDeviceHelper::GetDeviceInfo()
{
    DEVICE_INFO infoResult;

    clock_t tmTotalBegin = ::clock();

    clock_t tmBegin = ::clock();
    clock_t tmEnd = ::clock();

    infoResult.Baseboard = GetBaseBoardInfo();
    tmEnd = ::clock();
    _tprintf(_T("GetBaseBoardInfo time: %d\r\n"), tmEnd - tmBegin);
    tmBegin = ::clock();

    infoResult.Bios = GetBiosInfo();
    tmEnd = ::clock();
    _tprintf(_T("GetBiosInfo time: %d\r\n"), tmEnd - tmBegin);
    tmBegin = ::clock();

    infoResult.System = GetSystemInfo();
    tmEnd = ::clock();
    _tprintf(_T("GetSystemInfo time: %d\r\n"), tmEnd - tmBegin);
    tmBegin = ::clock();

    infoResult.Cpu = GetCpuInfo();
    tmEnd = ::clock();
    _tprintf(_T("GetCpuInfo time: %d\r\n"), tmEnd - tmBegin);
    tmBegin = ::clock();

    infoResult.Memory = GetPhysicalMemoryInfos();
    tmEnd = ::clock();
    _tprintf(_T("GetPhysicalMemoryInfos time: %d\r\n"), tmEnd - tmBegin);
    tmBegin = ::clock();

    infoResult.VideoController = GetVideoControllerInfos();
    tmEnd = ::clock();
    _tprintf(_T("GetVideoControllerInfos time: %d\r\n"), tmEnd - tmBegin);
    tmBegin = ::clock();

    tmEnd = ::clock();
    _tprintf(_T("GetDeviceInfo time: %d\r\n"), tmEnd - tmTotalBegin);

    return infoResult;
}

 main.cpp

#include <iostream>
#include "Win32Utils/CDeviceHelper.h"

int main()
{
    setlocale(LC_ALL, "");

    {
        CWmiQueryHelper obj;
        obj.Initialize();

        obj.QueryClass(_T("Win32_Processor"), [](uint64_t nIndex, const CWmiClassHelper Obj) {

            Obj.ConsolePrint(_T("Index: %d Class: %s\r\n"), nIndex, Obj.GetClass().c_str());
            Obj.PrintPropertyNonSystemOnly();

            }
        );
    }

    CDeviceHelper obj;

    clock_t tmBegin = ::clock();
    DEVICE_INFO info = obj.GetDeviceInfo();
    clock_t tmEnd = ::clock();

    printf("cost time: %d\r\n", tmEnd - tmBegin);


    return 0;
}

QT案例 使用WMI获取win_32类的属性值，包括Win32提供程序类中的属性
每个文章的示例都可以在下载资源中找到源码，有任何问题或修改可以左下角的QQ名片私聊联系.
12-15 1402
最近涉及到读取WINDOWS 系统电脑设备的各种信息，在一些特殊的PE或者简化系统中是没有WMI查询工具的，所以就自己写了个查询大部分WMI属性值的工具，免去了查网站的功夫。涉及到的方法内容就汇总做个总结。
关于wmi的参数拦截
被遗弃的庸才博客
07-24 1614
最近才刚刚上班，老大给了一个wmi的事件订阅的样本给我，叫我尝试拦截一下wmi的参数。 拿到任务首先去收一下有没有前人的代码可以借鉴（抄袭）的，看到有关于附加wmi的设备驱动的，好的，抄下来看看。具体实现是附加到WMIDataDevice设备上面，对IRP_MJ_SYSTEM_CONTROL进行过滤，然后就是什么都没有发生，之后看了一下微软给的wmi的驱动编程，由于网上没有现成的代码，本人技术拉跨，凭借拙略的英语阅读能力知道了要先注册下面这个函数，不然不给用IoWMIRegistrationControl
wmi应用（用于获取CPUID和硬盘ID)
05-08
wmi应用（用于获取CPUID和硬盘ID)
利用WMI获取系统的软硬件信息的学习与总结
Feng______的专栏
06-18 2470
文章学习于 http://blog.youkuaiyun.com/breaksoftware/article/details/8439975 感谢博主。
枚举物理内存属性
gandayong的专栏
08-27 378
 述返回有关安装在计算机上的物理内存的信息。有关在这段脚本中使用的 Win32_PhysicalMemoryArray 类的更多信息，请单击此处。支持平台Windows XP是Windows Server 2003是Windows 2000是Windows NT 4.0是，需要安装WMIWi
【c++】获取电脑硬件信息（操作系统,CPU,内存,GPU,显卡驱动,显示设备分辨率）
践行终生成长
09-10 9386
操作系统,CPU,内存,GPU 参考C/C++获取操作系统、CPU、内存信息、硬盘、IP和MAC、进程信息（windows和linux） 显卡驱动 参考【C++】WMI获取系统硬件信息(CPU/DISK/NetWork etc) #include <iostream> #include <string> #include <string.h> #include <winsock2.h> // include must before windo...
__cpuid
YiYueHuan的专栏
12-04 2805
https://msdn.microsoft.com/en-us/library/hskdteyh(VS.80).aspx Generates the cpuid instruction available on x86 and x64, which queries the processor for information about the supported features an
QT案例 使用WMI获取win-32类的属性值，包括Win32提供程序类中的属性 示例项目源代码
最新发布
12-14
文章：QT案例 使用WMI获取win_32类的属性值，包括Win32提供程序类中的属性 https://blog.youkuaiyun.com/qq_35554617/article/details/135016715?spm=1001.2014.3001.5502 中的示例项目源代码， 介绍了一个利用QT框架和WMI...
c#使用wmi查询usb设备信息示例
09-04
在这个特定的示例中，我们关注的是如何使用WMI来查询USB设备的相关信息。以下是你需要知道的关键知识点： 1. **WMI**：Windows Management Instrumentation是微软提供的一种系统管理接口，它允许应用程序获取和设置...
WMI获取硬件信息.rar
12-14
本资源“WMI获取硬件信息.rar”提供了获取计算机硬件信息的方法，包括主板、网卡、显卡和CPU等关键组件。通过解析这个压缩包中的内容，我们可以深入理解如何利用WMI来提取这些硬件数据。 1. **WMI基础** WMI是微软...
Windows客户端开发--使用WMI获取显卡详细信息(win32控制台程序)
热门推荐
一蓑烟雨任平生 也无风雨也无晴
07-08 1万+
昨天接受了WMI的基础知识，因为自己也是刚刚接触，也是应用型的，没有研究的更深更透。今天，就写一个真是的例子吧。比如说，我们要获得计算机显示适配器的详细信息，包括显卡的型号，显卡驱动的版本号，以及显卡当前的状态。Win32_VideoControllerclass Win32_VideoController : CIM_PCVideoController { uint16 AcceleratorCa
python 获取硬件信息_python获取windows的硬件信息
weixin_39548490的博客
11-26 460
#-*- coding: UTF-8 -*-'''=================================================@Project -> File ：CMDB -> collect_windows_info.py@IDE ：PyCharm@Author ：XuMou@Date ：2020/7/30 12:57=====================...
查询硬件信息
csfeng13的专栏
01-09 566
WMI技术介绍和应用——查询硬件信息 - cssealine 时间 2013-10-13 03:21:00 博客园-所有随笔区 相似文章 (0) 原文  http://www.cnblogs.com/cnsealine/p/3366300.html         因为一台电脑上可以有多块硬盘，所以在查询硬盘信息之前，我们需要明确我们要查询哪块硬盘。其中我们将要使用到《WMI技术
WMI-Win32_PhysicalMemory 内存条参数
weixin_34075268的博客
07-24 2876
为什么80%的码农都做不了架构师？>>> ...
Windows 如何查看主板的型号和厂家，以及支持的最大内存
qq_33157101的博客
02-18 8461
1.打开cmd命令行窗口，输入wmic,然后输入 baseboard get manufacturer,product 即可查看主板的型号和厂家 2.在cmd命令行窗口中输入 wmic memphysical get maxcapacity 3.查出来的数字33554432的单位是kb,需要转换为GB,33554432/1024/1024=32G,所以该电脑主板支持的最大内存是32G,理论上64位操作系统支持的内存是比较的大的，但是实际上要取决于电脑主板能够支持的内存大小。 系.
获取设备范例ID
多媒体编程、网络编程、系统编程、网络安全编程、驱动编程
07-09 2359
【原创】获取设备范例ID 标 题: 【原创】获取设备范例ID 作 者: downres 时 间: 2011-07-14,14:21:36 链 接: http://bbs.pediy.com/showthread.php?t=137138 近来正好在学习磁盘过滤驱动相关的知识，有一需求需要得到与磁盘分别对应的设备范例ID号，如上图所示，可以看出来
C#通过WMI获取USB设备信息教程
"C#通过WMI获取USB设备信息的代码示例" 在Windows操作系统中，管理系统硬件信息和事件的一种常用方法是使用Windows Management Instrumentation（WMI）。C#程序员可以利用.NET Framework提供的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值