WMI获取系统信息

最新推荐文章于 2023-07-05 09:18:07 发布
最新推荐文章于 2023-07-05 09:18:07 发布
阅读量2.6k 收藏 2
点赞数
文章标签： 编程 C
  1. // MyDlgExDlg.cpp : 实现文件   
  2. //   
  3.    
  4. #include "stdafx.h"   
  5. #include "MyDlgEx.h"   
  6. #include "MyDlgExDlg.h"   
  7.    
  8. #ifdef _DEBUG   
  9. #define new DEBUG_NEW   
  10. #endif   
  11.    
  12.    
  13. // 用于应用程序“关于”菜单项的 CAboutDlg 对话框   
  14.    
  15. class CAboutDlg : public CDialog   
  16. {   
  17. public:   
  18.     CAboutDlg();   
  19.    
  20. // 对话框数据   
  21.     enum { IDD = IDD_ABOUTBOX };   
  22.    
  23.     protected:   
  24.     virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持   
  25.    
  26. // 实现   
  27. protected:   
  28.     DECLARE_MESSAGE_MAP()   
  29. };   
  30.    
  31. CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)   
  32. {   
  33. }   
  34.    
  35. void CAboutDlg::DoDataExchange(CDataExchange* pDX)   
  36. {   
  37.     CDialog::DoDataExchange(pDX);   
  38. }   
  39.    
  40. BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)   
  41. END_MESSAGE_MAP()   
  42.    
  43.    
  44. // CMyDlgExDlg 对话框   
  45.    
  46.    
  47.    
  48.    
  49. CMyDlgExDlg::CMyDlgExDlg(CWnd* pParent /*=NULL*/)   
  50.     : CDialog(CMyDlgExDlg::IDD, pParent)   
  51. {   
  52.     m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);   
  53. }   
  54.    
  55. void CMyDlgExDlg::DoDataExchange(CDataExchange* pDX)   
  56. {   
  57.     CDialog::DoDataExchange(pDX);   
  58. }   
  59.    
  60. BEGIN_MESSAGE_MAP(CMyDlgExDlg, CDialog)   
  61.     ON_WM_SYSCOMMAND()   
  62.     ON_WM_PAINT()   
  63.     ON_WM_QUERYDRAGICON()   
  64.     //}}AFX_MSG_MAP   
  65.     ON_BN_CLICKED(IDC_BUTTON1, &CMyDlgExDlg::OnBnClickedButton1)   
  66.     ON_BN_CLICKED(IDC_BUTTON2, &CMyDlgExDlg::OnBnClickedButton2)   
  67.     ON_BN_CLICKED(IDC_BUTTON3, &CMyDlgExDlg::OnBnClickedButton3)   
  68.     ON_BN_CLICKED(IDC_BUTTON4, &CMyDlgExDlg::OnBnClickedButton4)   
  69.     ON_BN_CLICKED(IDC_BUTTON5, &CMyDlgExDlg::OnBnClickedButton5)   
  70.     ON_BN_CLICKED(IDC_BUTTON6, &CMyDlgExDlg::OnBnClickedButton6)   
  71.     ON_BN_CLICKED(IDC_BUTTON7, &CMyDlgExDlg::OnBnClickedButton7)   
  72.     ON_BN_CLICKED(IDC_BUTTON8, &CMyDlgExDlg::OnBnClickedButton8)   
  73.     ON_BN_CLICKED(IDC_BUTTON9, &CMyDlgExDlg::OnBnClickedButton9)   
  74.     ON_BN_CLICKED(IDC_BUTTON10, &CMyDlgExDlg::OnBnClickedButton10)   
  75.     ON_BN_CLICKED(IDC_BUTTON11, &CMyDlgExDlg::OnBnClickedButton11)   
  76.     ON_BN_CLICKED(IDC_BUTTON12, &CMyDlgExDlg::OnBnClickedButton12)   
  77.     ON_BN_CLICKED(IDC_BUTTON13, &CMyDlgExDlg::OnBnClickedButton13)   
  78.     ON_BN_CLICKED(IDC_BUTTON14, &CMyDlgExDlg::OnBnClickedButton14)   
  79.     ON_BN_CLICKED(IDC_BUTTON15, &CMyDlgExDlg::OnBnClickedButton15)   
  80.     ON_BN_CLICKED(IDC_BUTTON16, &CMyDlgExDlg::OnBnClickedButton16)   
  81.     ON_BN_CLICKED(IDC_BUTTON17, &CMyDlgExDlg::OnBnClickedButton17)   
  82.     ON_BN_CLICKED(IDC_BUTTON18, &CMyDlgExDlg::OnBnClickedButton18)   
  83.     ON_BN_CLICKED(IDC_BUTTON19, &CMyDlgExDlg::OnBnClickedButton19)   
  84.     ON_BN_CLICKED(IDC_BUTTON20, &CMyDlgExDlg::OnBnClickedButton20)   
  85.     ON_BN_CLICKED(IDC_BUTTON21, &CMyDlgExDlg::OnBnClickedButton21)   
  86.     ON_BN_CLICKED(IDC_BUTTON22, &CMyDlgExDlg::OnBnClickedButton22)   
  87.     ON_BN_CLICKED(IDC_BUTTON23, &CMyDlgExDlg::OnBnClickedButton23)   
  88.     ON_BN_CLICKED(IDC_BUTTON24, &CMyDlgExDlg::OnBnClickedButton24)   
  89.     ON_BN_CLICKED(IDC_BUTTON25, &CMyDlgExDlg::OnBnClickedButton25)   
  90.     ON_BN_CLICKED(IDC_BUTTON26, &CMyDlgExDlg::OnBnClickedButton26)   
  91.     ON_BN_CLICKED(IDC_BUTTON27, &CMyDlgExDlg::OnBnClickedButton27)   
  92.     ON_BN_CLICKED(IDC_BUTTON28, &CMyDlgExDlg::OnBnClickedButton28)   
  93.     ON_BN_CLICKED(IDC_BUTTON29, &CMyDlgExDlg::OnBnClickedButton29)   
  94.     ON_BN_CLICKED(IDC_BUTTON30, &CMyDlgExDlg::OnBnClickedButton30)   
  95.     ON_BN_CLICKED(IDC_BUTTON31, &CMyDlgExDlg::OnBnClickedButton31)   
  96.     ON_BN_CLICKED(IDC_BUTTON32, &CMyDlgExDlg::OnBnClickedButton32)   
  97.     ON_BN_CLICKED(IDC_BUTTON33, &CMyDlgExDlg::OnBnClickedButton33)   
  98.     ON_BN_CLICKED(IDC_BUTTON34, &CMyDlgExDlg::OnBnClickedButton34)   
  99.     ON_BN_CLICKED(IDC_BUTTON35, &CMyDlgExDlg::OnBnClickedButton35)   
  100.     ON_BN_CLICKED(IDC_BUTTON36, &CMyDlgExDlg::OnBnClickedButton36)   
  101.     ON_BN_CLICKED(IDC_BUTTON37, &CMyDlgExDlg::OnBnClickedButton37)   
  102.     ON_BN_CLICKED(IDC_BUTTON38, &CMyDlgExDlg::OnBnClickedButton38)   
  103.     ON_BN_CLICKED(IDC_BUTTON39, &CMyDlgExDlg::OnBnClickedButton39)   
  104.     ON_BN_CLICKED(IDC_BUTTON40, &CMyDlgExDlg::OnBnClickedButton40)   
  105.     ON_BN_CLICKED(IDC_BUTTON41, &CMyDlgExDlg::OnBnClickedButton41)   
  106.     ON_BN_CLICKED(IDC_BUTTON42, &CMyDlgExDlg::OnBnClickedButton42)   
  107.     ON_BN_CLICKED(IDC_BUTTON43, &CMyDlgExDlg::OnBnClickedButton43)   
  108.     ON_BN_CLICKED(IDC_BUTTON44, &CMyDlgExDlg::OnBnClickedButton44)   
  109. END_MESSAGE_MAP()   
  110.    
  111.    
  112. // CMyDlgExDlg 消息处理程序   
  113.    
  114. BOOL CMyDlgExDlg::OnInitDialog()   
  115. {   
  116.     CDialog::OnInitDialog();   
  117.    
  118.     // 将“关于...”菜单项添加到系统菜单中。   
  119.    
  120.     // IDM_ABOUTBOX 必须在系统命令范围内。   
  121.     ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);   
  122.     ASSERT(IDM_ABOUTBOX < 0xF000);   
  123.    
  124.     CMenu* pSysMenu = GetSystemMenu(FALSE);   
  125.     if (pSysMenu != NULL)   
  126.     {   
  127.         CString strAboutMenu;   
  128.         strAboutMenu.LoadString(IDS_ABOUTBOX);   
  129.         if (!strAboutMenu.IsEmpty())   
  130.         {   
  131.             pSysMenu->AppendMenu(MF_SEPARATOR);   
  132.             pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);   
  133.         }   
  134.     }   
  135.    
  136.     // 设置此对话框的图标。当应用程序主窗口不是对话框时，框架将自动   
  137.     //  执行此操作   
  138.     SetIcon(m_hIcon, TRUE);         // 设置大图标   
  139.     SetIcon(m_hIcon, FALSE);        // 设置小图标   
  140.    
  141.     // TODO: 在此添加额外的初始化代码   
  142.    
  143.     return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE   
  144. }   
  145.    
  146. void CMyDlgExDlg::OnSysCommand(UINT nID, LPARAM lParam)   
  147. {   
  148.     if ((nID & 0xFFF0) == IDM_ABOUTBOX)   
  149.     {   
  150.         CAboutDlg dlgAbout;   
  151.         dlgAbout.DoModal();   
  152.     }   
  153.     else   
  154.     {   
  155.         CDialog::OnSysCommand(nID, lParam);   
  156.     }   
  157. }   
  158.    
  159. // 如果向对话框添加最小化按钮，则需要下面的代码   
  160. //  来绘制该图标。对于使用文档/视图模型的 MFC 应用程序，   
  161. //  这将由框架自动完成。   
  162.    
  163. void CMyDlgExDlg::OnPaint()   
  164. {   
  165.     if (IsIconic())   
  166.     {   
  167.         CPaintDC dc(this); // 用于绘制的设备上下文   
  168.    
  169.         SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);   
  170.    
  171.         // 使图标在工作矩形中居中   
  172.         int cxIcon = GetSystemMetrics(SM_CXICON);   
  173.         int cyIcon = GetSystemMetrics(SM_CYICON);   
  174.         CRect rect;   
  175.         GetClientRect(&rect);   
  176.         int x = (rect.Width() - cxIcon + 1) / 2;   
  177.         int y = (rect.Height() - cyIcon + 1) / 2;   
  178.    
  179.         // 绘制图标   
  180.         dc.DrawIcon(x, y, m_hIcon);   
  181.     }   
  182.     else   
  183.     {   
  184.         CDialog::OnPaint();   
  185.     }   
  186. }   
  187.    
  188. //当用户拖动最小化窗口时系统调用此函数取得光标显示。   
  189. //   
  190. HCURSOR CMyDlgExDlg::OnQueryDragIcon()   
  191. {   
  192.     return static_cast<HCURSOR>(m_hIcon);   
  193. }   
  194.    
  195.    
  196. void CMyDlgExDlg::OnBnClickedButton1()   
  197. {//启动Windows管理体系结构(WMI)   
  198.     CString MyCommand="cmd /c \"wmimgmt.msc\"";   
  199.     WinExec(MyCommand,SW_HIDE);    
  200. }   
  201.    
  202. void CMyDlgExDlg::OnBnClickedButton2()   
  203. {//获取指定进程的详细进程信息   
  204.     CString MyCommand="cmd /c wmic process WHERE Name='Notepad.exe' list FULL > c:\\MyProc.txt";   
  205.     WinExec(MyCommand,SW_HIDE);   
  206.     Sleep(2000);   
  207.     CString MyFile="c:\\MyProc.txt";   
  208.     SHELLEXECUTEINFO MyExe;                 
  209.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  210.     MyExe.cbSize=sizeof (MyExe) ;   
  211.     MyExe.lpVerb="open" ;   
  212.     MyExe.lpFile=MyFile;   
  213.     MyExe.lpParameters=NULL;   
  214.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  215.     MyExe.nShow=SW_SHOWDEFAULT ;   
  216.     ShellExecuteEx (&MyExe);   
  217. }   
  218.    
  219. void CMyDlgExDlg::OnBnClickedButton3()   
  220. {//获取指定进程的进程简要信息   
  221.     CString MyCommand="cmd /c wmic process WHERE Name='Notepad.exe' list Brief > c:\\MyProc.txt";   
  222.     WinExec(MyCommand,SW_HIDE);   
  223.     Sleep(2000);   
  224.     CString MyFile="c:\\MyProc.txt";   
  225.     SHELLEXECUTEINFO MyExe;                 
  226.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  227.     MyExe.cbSize=sizeof (MyExe) ;   
  228.     MyExe.lpVerb="open" ;   
  229.     MyExe.lpFile=MyFile;   
  230.     MyExe.lpParameters=NULL;   
  231.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  232.     MyExe.nShow=SW_SHOWDEFAULT ;   
  233.     ShellExecuteEx (&MyExe);       
  234. }   
  235.    
  236. void CMyDlgExDlg::OnBnClickedButton4()   
  237. {//获取指定进程的执行路径信息   
  238.     CString MyCommand="cmd /c wmic process WHERE Name='Notepad.exe' Get ExecutablePath > c:\\MyProc.txt";   
  239.     WinExec(MyCommand,SW_HIDE);   
  240.     Sleep(2000);   
  241.     CString MyFile="c:\\MyProc.txt";   
  242.     SHELLEXECUTEINFO MyExe;                 
  243.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  244.     MyExe.cbSize=sizeof (MyExe) ;   
  245.     MyExe.lpVerb="open" ;   
  246.     MyExe.lpFile=MyFile;   
  247.     MyExe.lpParameters=NULL;   
  248.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  249.     MyExe.nShow=SW_SHOWDEFAULT ;   
  250.     ShellExecuteEx (&MyExe);           
  251. }   
  252.    
  253. void CMyDlgExDlg::OnBnClickedButton5()   
  254. {//获取所有进程的执行路径信息   
  255.     CString MyCommand="cmd /c wmic process  get caption, ExecutablePath > c:\\MyProc.txt";   
  256.     WinExec(MyCommand,SW_HIDE);   
  257.     Sleep(2000);   
  258.     CString MyFile="c:\\MyProc.txt";   
  259.     SHELLEXECUTEINFO MyExe;                 
  260.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  261.     MyExe.cbSize=sizeof (MyExe) ;   
  262.     MyExe.lpVerb="open" ;   
  263.     MyExe.lpFile=MyFile;   
  264.     MyExe.lpParameters=NULL;   
  265.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  266.     MyExe.nShow=SW_SHOWDEFAULT ;   
  267.     ShellExecuteEx (&MyExe);               
  268. }   
  269.    
  270. void CMyDlgExDlg::OnBnClickedButton6()   
  271. {//将获取的进程信息保存为XML文件   
  272.     CString MyCommand="cmd /c  wmic process list /format:XML  > c:\\MyProc.xml";   
  273.     WinExec(MyCommand,SW_HIDE);   
  274.     Sleep(2000);   
  275.     CString MyFile="c:\\MyProc.xml";   
  276.     SHELLEXECUTEINFO MyExe;                 
  277.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  278.     MyExe.cbSize=sizeof (MyExe) ;   
  279.     MyExe.lpVerb="open" ;   
  280.     MyExe.lpFile=MyFile;   
  281.     MyExe.lpParameters=NULL;   
  282.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  283.     MyExe.nShow=SW_SHOWDEFAULT ;   
  284.     ShellExecuteEx (&MyExe);                   
  285. }   
  286.    
  287. void CMyDlgExDlg::OnBnClickedButton7()   
  288. {//获取所有进程的内存使用信息   
  289.     CString MyCommand="cmd /c wmic process list Memory > c:\\MyProc.txt";   
  290.     WinExec(MyCommand,SW_HIDE);   
  291.     Sleep(10000);   
  292.     CString MyFile="c:\\MyProc.txt";   
  293.     SHELLEXECUTEINFO MyExe;                 
  294.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  295.     MyExe.cbSize=sizeof (MyExe) ;   
  296.     MyExe.lpVerb="open" ;   
  297.     MyExe.lpFile=MyFile;   
  298.     MyExe.lpParameters=NULL;   
  299.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  300.     MyExe.nShow=SW_SHOWDEFAULT ;   
  301.     ShellExecuteEx (&MyExe);           
  302. }   
  303.    
  304. void CMyDlgExDlg::OnBnClickedButton8()   
  305. {//获取所有进程的统计数据信息   
  306.     CString MyCommand="cmd /c wmic process list statistics > c:\\MyProc.txt";   
  307.     WinExec(MyCommand,SW_HIDE);   
  308.     Sleep(15000);   
  309.     CString MyFile="c:\\MyProc.txt";   
  310.     SHELLEXECUTEINFO MyExe;                 
  311.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  312.     MyExe.cbSize=sizeof (MyExe) ;   
  313.     MyExe.lpVerb="open" ;   
  314.     MyExe.lpFile=MyFile;   
  315.     MyExe.lpParameters=NULL;   
  316.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  317.     MyExe.nShow=SW_SHOWDEFAULT ;   
  318.     ShellExecuteEx (&MyExe);           
  319. }   
  320.    
  321. void CMyDlgExDlg::OnBnClickedButton9()   
  322. {//获取所有进程的IO数据信息   
  323.     CString MyCommand="cmd /c wmic process list IO > c:\\MyProc.txt";   
  324.     WinExec(MyCommand,SW_HIDE);   
  325.     Sleep(15000);   
  326.     CString MyFile="c:\\MyProc.txt";   
  327.     SHELLEXECUTEINFO MyExe;                 
  328.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  329.     MyExe.cbSize=sizeof (MyExe) ;   
  330.     MyExe.lpVerb="open" ;   
  331.     MyExe.lpFile=MyFile;   
  332.     MyExe.lpParameters=NULL;   
  333.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  334.     MyExe.nShow=SW_SHOWDEFAULT ;   
  335.     ShellExecuteEx (&MyExe);               
  336. }   
  337.    
  338. void CMyDlgExDlg::OnBnClickedButton10()   
  339. {//获取BIOS的名称和制造商信息   
  340.     CString MyCommand="cmd /c wmic bios get name,Manufacturer /value  > c:\\MyWMIC.txt";   
  341.     WinExec(MyCommand,SW_HIDE);   
  342.     Sleep(1000);   
  343.     CString MyFile="c:\\MyWMIC.txt";   
  344.     SHELLEXECUTEINFO MyExe;                 
  345.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  346.     MyExe.cbSize=sizeof (MyExe) ;   
  347.     MyExe.lpVerb="open" ;   
  348.     MyExe.lpFile=MyFile;   
  349.     MyExe.lpParameters=NULL;   
  350.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  351.     MyExe.nShow=SW_SHOWDEFAULT ;   
  352.     ShellExecuteEx (&MyExe);                   
  353. }   
  354.    
  355. void CMyDlgExDlg::OnBnClickedButton11()   
  356. {//获取CDROM所在的驱动器名称   
  357.     CString MyCommand="cmd /c wmic CDROM get Drive /value  > c:\\MyWMIC.txt";   
  358.     WinExec(MyCommand,SW_HIDE);   
  359.     Sleep(1000);   
  360.     CString MyFile="c:\\MyWMIC.txt";   
  361.     SHELLEXECUTEINFO MyExe;                 
  362.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  363.     MyExe.cbSize=sizeof (MyExe) ;   
  364.     MyExe.lpVerb="open" ;   
  365.     MyExe.lpFile=MyFile;   
  366.     MyExe.lpParameters=NULL;   
  367.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  368.     MyExe.nShow=SW_SHOWDEFAULT ;   
  369.     ShellExecuteEx (&MyExe);                       
  370. }   
  371.    
  372. void CMyDlgExDlg::OnBnClickedButton12()   
  373. {//获取计算机系统的角色信息   
  374.     CString MyCommand="cmd /c wmic COMPUTERSYSTEM GET Roles  /value > c:\\MyWMIC.txt";   
  375.     WinExec(MyCommand,SW_HIDE);   
  376.     Sleep(1000);   
  377.     CString MyFile="c:\\MyWMIC.txt";   
  378.     SHELLEXECUTEINFO MyExe;                 
  379.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  380.     MyExe.cbSize=sizeof (MyExe) ;   
  381.     MyExe.lpVerb="open" ;   
  382.     MyExe.lpFile=MyFile;   
  383.     MyExe.lpParameters=NULL;   
  384.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  385.     MyExe.nShow=SW_SHOWDEFAULT ;   
  386.     ShellExecuteEx (&MyExe);                           
  387. }   
  388.    
  389. void CMyDlgExDlg::OnBnClickedButton13()   
  390. {//获取CPU处理器的ID号码信息   
  391.     CString MyCommand="cmd /c wmic CPU GET ProcessorID  /value > c:\\MyWMIC.txt";   
  392.     WinExec(MyCommand,SW_HIDE);   
  393.     Sleep(1000);   
  394.     CString MyFile="c:\\MyWMIC.txt";   
  395.     SHELLEXECUTEINFO MyExe;                 
  396.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  397.     MyExe.cbSize=sizeof (MyExe) ;   
  398.     MyExe.lpVerb="open" ;   
  399.     MyExe.lpFile=MyFile;   
  400.     MyExe.lpParameters=NULL;   
  401.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  402.     MyExe.nShow=SW_SHOWDEFAULT ;   
  403.     ShellExecuteEx (&MyExe);                               
  404. }   
  405.    
  406. void CMyDlgExDlg::OnBnClickedButton14()   
  407. {//获取计算机的DOCM程序名称信息   
  408.     CString MyCommand="cmd /c wmic DCOMAPP GET Name  > c:\\MyWMIC.txt";   
  409.     WinExec(MyCommand,SW_HIDE);   
  410.     Sleep(5000);   
  411.     CString MyFile="c:\\MyWMIC.txt";   
  412.     SHELLEXECUTEINFO MyExe;                 
  413.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  414.     MyExe.cbSize=sizeof (MyExe) ;   
  415.     MyExe.lpVerb="open" ;   
  416.     MyExe.lpFile=MyFile;   
  417.     MyExe.lpParameters=NULL;   
  418.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  419.     MyExe.nShow=SW_SHOWDEFAULT ;   
  420.     ShellExecuteEx (&MyExe);           
  421. }   
  422.    
  423. void CMyDlgExDlg::OnBnClickedButton15()   
  424. {//获取磁盘(非逻辑分区)的容量大小   
  425.     CString MyCommand="cmd /c wmic diskdrive GET Name,size /value  > c:\\MyWMIC.txt";   
  426.     WinExec(MyCommand,SW_HIDE);   
  427.     Sleep(1000);   
  428.     CString MyFile="c:\\MyWMIC.txt";   
  429.     SHELLEXECUTEINFO MyExe;                 
  430.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  431.     MyExe.cbSize=sizeof (MyExe) ;   
  432.     MyExe.lpVerb="open" ;   
  433.     MyExe.lpFile=MyFile;   
  434.     MyExe.lpParameters=NULL;   
  435.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  436.     MyExe.nShow=SW_SHOWDEFAULT ;   
  437.     ShellExecuteEx (&MyExe);               
  438. }   
  439.    
  440. void CMyDlgExDlg::OnBnClickedButton16()   
  441. {//获取直接内存访问(DMA)频道信息   
  442.     CString MyCommand="cmd /c wmic dmachannel list brief  > c:\\MyWMIC.txt";   
  443.     WinExec(MyCommand,SW_HIDE);   
  444.     Sleep(1000);   
  445.     CString MyFile="c:\\MyWMIC.txt";   
  446.     SHELLEXECUTEINFO MyExe;                 
  447.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  448.     MyExe.cbSize=sizeof (MyExe) ;   
  449.     MyExe.lpVerb="open" ;   
  450.     MyExe.lpFile=MyFile;   
  451.     MyExe.lpParameters=NULL;   
  452.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  453.     MyExe.nShow=SW_SHOWDEFAULT ;   
  454.     ShellExecuteEx (&MyExe);               
  455. }   
  456.    
  457. void CMyDlgExDlg::OnBnClickedButton17()   
  458. {//获取当前系统的所有环境变量及值   
  459.     CString MyCommand="cmd /c wmic environment get Name,variablevalue  > c:\\MyWMIC.txt";   
  460.     WinExec(MyCommand,SW_HIDE);   
  461.     Sleep(5000);   
  462.     CString MyFile="c:\\MyWMIC.txt";   
  463.     SHELLEXECUTEINFO MyExe;                 
  464.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  465.     MyExe.cbSize=sizeof (MyExe) ;   
  466.     MyExe.lpVerb="open" ;   
  467.     MyExe.lpFile=MyFile;   
  468.     MyExe.lpParameters=NULL;   
  469.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  470.     MyExe.nShow=SW_SHOWDEFAULT ;   
  471.     ShellExecuteEx (&MyExe);           
  472. }   
  473.    
  474. void CMyDlgExDlg::OnBnClickedButton18()   
  475. {//获取系统的组成员账户及其职责   
  476.     CString MyCommand="cmd /c wmic group list full  > c:\\MyWMIC.txt";   
  477.     WinExec(MyCommand,SW_HIDE);   
  478.     Sleep(1000);   
  479.     CString MyFile="c:\\MyWMIC.txt";   
  480.     SHELLEXECUTEINFO MyExe;                 
  481.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  482.     MyExe.cbSize=sizeof (MyExe) ;   
  483.     MyExe.lpVerb="open" ;   
  484.     MyExe.lpFile=MyFile;   
  485.     MyExe.lpParameters=NULL;   
  486.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  487.     MyExe.nShow=SW_SHOWDEFAULT ;   
  488.     ShellExecuteEx (&MyExe);           
  489. }   
  490.    
  491. void CMyDlgExDlg::OnBnClickedButton19()   
  492. {//获取当前系统的IDE控制器信息   
  493.     CString MyCommand="cmd /c wmic IDECONTROLLER list full  > c:\\MyWMIC.txt";   
  494.     WinExec(MyCommand,SW_HIDE);   
  495.     Sleep(1000);   
  496.     CString MyFile="c:\\MyWMIC.txt";   
  497.     SHELLEXECUTEINFO MyExe;                 
  498.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  499.     MyExe.cbSize=sizeof (MyExe) ;   
  500.     MyExe.lpVerb="open" ;   
  501.     MyExe.lpFile=MyFile;   
  502.     MyExe.lpParameters=NULL;   
  503.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  504.     MyExe.nShow=SW_SHOWDEFAULT ;   
  505.     ShellExecuteEx (&MyExe);               
  506. }   
  507.    
  508. void CMyDlgExDlg::OnBnClickedButton20()   
  509. {//获取当前系统的逻辑分区卷序列号   
  510.     CString MyCommand="cmd /c wmic logicalDisk get  name,volumeserialnumber /value> c:\\MyWMIC.txt";   
  511.     WinExec(MyCommand,SW_HIDE);   
  512.     Sleep(8000);   
  513.     CString MyFile="c:\\MyWMIC.txt";   
  514.     SHELLEXECUTEINFO MyExe;                 
  515.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  516.     MyExe.cbSize=sizeof (MyExe) ;   
  517.     MyExe.lpVerb="open" ;   
  518.     MyExe.lpFile=MyFile;   
  519.     MyExe.lpParameters=NULL;   
  520.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  521.     MyExe.nShow=SW_SHOWDEFAULT ;   
  522.     ShellExecuteEx (&MyExe);           
  523. }   
  524.    
  525. void CMyDlgExDlg::OnBnClickedButton21()   
  526. {//获取当前系统的缓存管理信息   
  527.     CString MyCommand="cmd /c wmic memcache list full > c:\\MyWMIC.txt";   
  528.     WinExec(MyCommand,SW_HIDE);   
  529.     Sleep(2000);   
  530.     CString MyFile="c:\\MyWMIC.txt";   
  531.     SHELLEXECUTEINFO MyExe;                 
  532.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  533.     MyExe.cbSize=sizeof (MyExe) ;   
  534.     MyExe.lpVerb="open" ;   
  535.     MyExe.lpFile=MyFile;   
  536.     MyExe.lpParameters=NULL;   
  537.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  538.     MyExe.nShow=SW_SHOWDEFAULT ;   
  539.     ShellExecuteEx (&MyExe);               
  540. }   
  541.    
  542. void CMyDlgExDlg::OnBnClickedButton22()   
  543. {//获取当前系统的虚拟内存信息   
  544.     CString MyCommand="cmd /c wmic memlogical get totalvirtualmemory /value > c:\\MyWMIC.txt";   
  545.     WinExec(MyCommand,SW_HIDE);   
  546.     Sleep(2000);   
  547.     CString MyFile="c:\\MyWMIC.txt";   
  548.     SHELLEXECUTEINFO MyExe;                 
  549.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  550.     MyExe.cbSize=sizeof (MyExe) ;   
  551.     MyExe.lpVerb="open" ;   
  552.     MyExe.lpFile=MyFile;   
  553.     MyExe.lpParameters=NULL;   
  554.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  555.     MyExe.nShow=SW_SHOWDEFAULT ;   
  556.     ShellExecuteEx (&MyExe);                   
  557. }   
  558.    
  559. void CMyDlgExDlg::OnBnClickedButton23()   
  560. {//获取当前系统的物理内存信息   
  561.     CString MyCommand="cmd /c wmic memlogical get totalphysicalmemory /value > c:\\MyWMIC.txt";   
  562.     WinExec(MyCommand,SW_HIDE);   
  563.     Sleep(2000);   
  564.     CString MyFile="c:\\MyWMIC.txt";   
  565.     SHELLEXECUTEINFO MyExe;                 
  566.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  567.     MyExe.cbSize=sizeof (MyExe) ;   
  568.     MyExe.lpVerb="open" ;   
  569.     MyExe.lpFile=MyFile;   
  570.     MyExe.lpParameters=NULL;   
  571.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  572.     MyExe.nShow=SW_SHOWDEFAULT ;   
  573.     ShellExecuteEx (&MyExe);                   
  574. }   
  575.    
  576. void CMyDlgExDlg::OnBnClickedButton24()   
  577. {//获取当前系统的网络客户端信息   
  578.     CString MyCommand="cmd /c wmic netclient list full > c:\\MyWMIC.txt";   
  579.     WinExec(MyCommand,SW_HIDE);   
  580.     Sleep(2000);   
  581.     CString MyFile="c:\\MyWMIC.txt";   
  582.     SHELLEXECUTEINFO MyExe;                 
  583.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  584.     MyExe.cbSize=sizeof (MyExe) ;   
  585.     MyExe.lpVerb="open" ;   
  586.     MyExe.lpFile=MyFile;   
  587.     MyExe.lpParameters=NULL;   
  588.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  589.     MyExe.nShow=SW_SHOWDEFAULT ;   
  590.     ShellExecuteEx (&MyExe);                       
  591. }   
  592.    
  593. void CMyDlgExDlg::OnBnClickedButton25()   
  594. {//获取用户最近登录系统的日期信息   
  595.     CString MyCommand="cmd /c wmic netlogin get name,lastlogon /value> c:\\MyWMIC.txt";   
  596.     WinExec(MyCommand,SW_HIDE);   
  597.     Sleep(2000);   
  598.     CString MyFile="c:\\MyWMIC.txt";   
  599.     SHELLEXECUTEINFO MyExe;                 
  600.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  601.     MyExe.cbSize=sizeof (MyExe) ;   
  602.     MyExe.lpVerb="open" ;   
  603.     MyExe.lpFile=MyFile;   
  604.     MyExe.lpParameters=NULL;   
  605.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  606.     MyExe.nShow=SW_SHOWDEFAULT ;   
  607.     ShellExecuteEx (&MyExe);                       
  608. }   
  609.    
  610. void CMyDlgExDlg::OnBnClickedButton26()   
  611. {//获取当前操作系统的安装日期   
  612.     CString MyCommand="cmd /c wmic os get installdate /value> c:\\MyWMIC.txt";   
  613.     WinExec(MyCommand,SW_HIDE);   
  614.     Sleep(2000);   
  615.     CString MyFile="c:\\MyWMIC.txt";   
  616.     SHELLEXECUTEINFO MyExe;                 
  617.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  618.     MyExe.cbSize=sizeof (MyExe) ;   
  619.     MyExe.lpVerb="open" ;   
  620.     MyExe.lpFile=MyFile;   
  621.     MyExe.lpParameters=NULL;   
  622.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  623.     MyExe.nShow=SW_SHOWDEFAULT ;   
  624.     ShellExecuteEx (&MyExe);                           
  625. }   
  626.    
  627. void CMyDlgExDlg::OnBnClickedButton27()   
  628. {//获取当前操作系统的安装包管理信息   
  629.     CString MyCommand="cmd /c wmic product list full> c:\\MyWMIC.txt";   
  630.     WinExec(MyCommand,SW_HIDE);   
  631.     Sleep(5000);   
  632.     CString MyFile="c:\\MyWMIC.txt";   
  633.     SHELLEXECUTEINFO MyExe;                 
  634.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  635.     MyExe.cbSize=sizeof (MyExe) ;   
  636.     MyExe.lpVerb="open" ;   
  637.     MyExe.lpFile=MyFile;   
  638.     MyExe.lpParameters=NULL;   
  639.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  640.     MyExe.nShow=SW_SHOWDEFAULT ;   
  641.     ShellExecuteEx (&MyExe);           
  642. }   
  643.    
  644. void CMyDlgExDlg::OnBnClickedButton28()   
  645. {//获取当前系统已经安装的软件信息   
  646.     CString MyCommand="cmd /c wmic softwarefeature list full > c:\\MyWMIC.txt";   
  647.     WinExec(MyCommand,SW_HIDE);   
  648.     Sleep(10000);   
  649.     CString MyFile="c:\\MyWMIC.txt";   
  650.     SHELLEXECUTEINFO MyExe;                 
  651.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  652.     MyExe.cbSize=sizeof (MyExe) ;   
  653.     MyExe.lpVerb="open" ;   
  654.     MyExe.lpFile=MyFile;   
  655.     MyExe.lpParameters=NULL;   
  656.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  657.     MyExe.nShow=SW_SHOWDEFAULT ;   
  658.     ShellExecuteEx (&MyExe);       
  659. }   
  660.    
  661. void CMyDlgExDlg::OnBnClickedButton29()   
  662. {//获取系统已经安装的声音设备信息   
  663.     CString MyCommand="cmd /c wmic Sounddev list full > c:\\MyWMIC.txt";   
  664.     WinExec(MyCommand,SW_HIDE);   
  665.     Sleep(1000);   
  666.     CString MyFile="c:\\MyWMIC.txt";   
  667.     SHELLEXECUTEINFO MyExe;                 
  668.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  669.     MyExe.cbSize=sizeof (MyExe) ;   
  670.     MyExe.lpVerb="open" ;   
  671.     MyExe.lpFile=MyFile;   
  672.     MyExe.lpParameters=NULL;   
  673.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  674.     MyExe.nShow=SW_SHOWDEFAULT ;   
  675.     ShellExecuteEx (&MyExe);       
  676. }   
  677.    
  678. void CMyDlgExDlg::OnBnClickedButton30()   
  679. {//获取系统启动时自动运行的命令信息   
  680.     CString MyCommand="cmd /c wmic startup get command > c:\\MyWMIC.txt";   
  681.     WinExec(MyCommand,SW_HIDE);   
  682.     Sleep(1000);   
  683.     CString MyFile="c:\\MyWMIC.txt";   
  684.     SHELLEXECUTEINFO MyExe;                 
  685.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  686.     MyExe.cbSize=sizeof (MyExe) ;   
  687.     MyExe.lpVerb="open" ;   
  688.     MyExe.lpFile=MyFile;   
  689.     MyExe.lpParameters=NULL;   
  690.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  691.     MyExe.nShow=SW_SHOWDEFAULT ;   
  692.     ShellExecuteEx (&MyExe);           
  693. }   
  694.    
  695. void CMyDlgExDlg::OnBnClickedButton31()   
  696. {//获取当前系统的系统插槽信息   
  697.     CString MyCommand="cmd /c wmic SYSTEMSLOT get tag,SlotDesignation /value > c:\\MyWMIC.txt";   
  698.     WinExec(MyCommand,SW_HIDE);   
  699.     Sleep(1000);   
  700.     CString MyFile="c:\\MyWMIC.txt";   
  701.     SHELLEXECUTEINFO MyExe;                 
  702.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  703.     MyExe.cbSize=sizeof (MyExe) ;   
  704.     MyExe.lpVerb="open" ;   
  705.     MyExe.lpFile=MyFile;   
  706.     MyExe.lpParameters=NULL;   
  707.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  708.     MyExe.nShow=SW_SHOWDEFAULT ;   
  709.     ShellExecuteEx (&MyExe);               
  710. }   
  711.    
  712. void CMyDlgExDlg::OnBnClickedButton32()   
  713. {//获取当前系统设置的用户账户信息   
  714.     CString MyCommand="cmd /c wmic useraccount get name > c:\\MyWMIC.txt";   
  715.     WinExec(MyCommand,SW_HIDE);   
  716.     Sleep(1000);   
  717.     CString MyFile="c:\\MyWMIC.txt";   
  718.     SHELLEXECUTEINFO MyExe;                 
  719.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  720.     MyExe.cbSize=sizeof (MyExe) ;   
  721.     MyExe.lpVerb="open" ;   
  722.     MyExe.lpFile=MyFile;   
  723.     MyExe.lpParameters=NULL;   
  724.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  725.     MyExe.nShow=SW_SHOWDEFAULT ;   
  726.     ShellExecuteEx (&MyExe);               
  727. }   
  728.    
  729.    
  730. #include <atlbase.h>   
  731. #include <afxpriv.h>   
  732. #include <WbemIdl.h>   
  733. #pragma comment(lib,"WbemUuid.lib")   
  734. class CMyWMI   
  735. {   
  736. protected:   
  737.     IEnumWbemClassObject* m_pMyEnumWbem;   
  738.     IWbemClassObject* m_pMyWbemObj;   
  739.     IWbemServices* m_pMyWbemSvc;   
  740.     IWbemLocator* m_pMyWbemLoc;   
  741. public:   
  742.     CMyWMI(void)   
  743.     {   
  744.         m_pMyWbemSvc=0;   
  745.         m_pMyWbemLoc=0;   
  746.     }   
  747.     ~CMyWMI(void)   
  748.     {   
  749.         m_pMyWbemSvc=0;   
  750.         m_pMyWbemLoc=0;   
  751.     }   
  752. public:   
  753.     HRESULT InitializeComInterface()   
  754.     {   
  755.         HRESULT MyHResult=CoInitializeEx(0,COINIT_MULTITHREADED);   
  756.         VERIFY(SUCCEEDED(MyHResult));   
  757.         MyHResult=CoInitializeSecurity(0,-1,0,0,RPC_C_AUTHN_LEVEL_PKT,RPC_C_IMP_LEVEL_IMPERSONATE,0,EOAC_NONE,0);   
  758.         VERIFY(SUCCEEDED(MyHResult));          
  759.         MyHResult=CoCreateInstance(CLSID_WbemLocator,0,CLSCTX_INPROC_SERVER,IID_IWbemLocator,(LPVOID*)&m_pMyWbemLoc);   
  760.         VERIFY(SUCCEEDED(MyHResult));   
  761.         MyHResult=m_pMyWbemLoc->ConnectServer(CComBSTR(L"ROOT\\CIMV2"),0,0,0,0,0,0,&m_pMyWbemSvc);   
  762.         VERIFY(SUCCEEDED(MyHResult));   
  763.         MyHResult=CoSetProxyBlanket(m_pMyWbemSvc,RPC_C_AUTHN_WINNT,RPC_C_AUTHZ_NONE,0,RPC_C_AUTHN_LEVEL_CALL,RPC_C_IMP_LEVEL_IMPERSONATE,0,EOAC_NONE);   
  764.         VERIFY(SUCCEEDED(MyHResult));   
  765.         return(MyHResult);   
  766.     }   
  767.     HRESULT ReleaseComInterface()   
  768.     {   
  769.         HRESULT MyHResult=m_pMyWbemSvc->Release();   
  770.         MyHResult=m_pMyWbemLoc->Release();   
  771.         CoUninitialize();   
  772.         return(MyHResult);   
  773.     }   
  774.     CString CMyWMI::TransferData(const LPVARIANT pVar) const   
  775.     {   
  776.         USES_CONVERSION;   
  777.         CComBSTR HUGEP* pMyBstr;   
  778.         BYTE HUGEP* pMyBuf;   
  779.         CString MyData,MyTip;   
  780.         LONG iMyLow,iMyHigh;   
  781.         HRESULT MyHResult;     
  782.         switch(pVar->vt)   
  783.         {   
  784.             case VT_BSTR:   
  785.                 MyData=W2T(pVar->bstrVal);   
  786.                 break;   
  787.             case VT_BOOL:   
  788.                 if(VARIANT_TRUE==pVar->boolVal)    
  789.                     MyData="是";   
  790.                 else    
  791.                     MyData="否";   
  792.                 break;   
  793.             case VT_I4:   
  794.                 MyData.Format("%d",pVar->lVal);   
  795.                 break;   
  796.             case VT_UI1:   
  797.                 MyData.Format("%d",pVar->bVal);   
  798.                 break;   
  799.             case VT_UI4:   
  800.                 MyData.Format("%d",pVar->ulVal);   
  801.                 break;   
  802.             case VT_BSTR|VT_ARRAY:   
  803.                 MyHResult=SafeArrayAccessData(pVar->parray,(void HUGEP**)&pMyBstr);   
  804.                 MyHResult=SafeArrayUnaccessData(pVar->parray);   
  805.                 MyData=W2T(pMyBstr->m_str);   
  806.                 break;   
  807.             case VT_I4|VT_ARRAY:   
  808.                 SafeArrayGetLBound(pVar->parray,1,&iMyLow);    
  809.                 SafeArrayGetUBound(pVar->parray,1,&iMyHigh);        
  810.                 MyHResult=SafeArrayAccessData(pVar->parray,(void HUGEP**)&pMyBuf);   
  811.                 MyHResult=SafeArrayUnaccessData(pVar->parray);                  
  812.                 iMyHigh=min(iMyHigh,MAX_PATH*2-1);   
  813.                 for(int i=iMyLow;i<=iMyHigh;++i)   
  814.                 {   
  815.                     MyTip.Format("%02X ",pMyBuf[i]);   
  816.                     MyData+=MyTip;   
  817.                 }   
  818.                 break;   
  819.             default:   
  820.                 break;   
  821.         }   
  822.         return(MyData);   
  823.     }   
  824.     CString CMyWMI::GetQueryData(CString MyWQL,CString MyItem)   
  825.     {   
  826.         USES_CONVERSION;   
  827.         CComBSTR MyQuery=CComBSTR(MyWQL);   
  828.         CString MyResult,MyData;   
  829.         VARIANT MyVar;   
  830.         ULONG MyReturn;   
  831.         HRESULT MyHResult;     
  832.         m_pMyEnumWbem=0;   
  833.         m_pMyWbemObj=0;   
  834.         MyHResult=m_pMyWbemSvc->ExecQuery(CComBSTR("WQL"),MyQuery,WBEM_FLAG_FORWARD_ONLY|WBEM_FLAG_RETURN_IMMEDIATELY,0,&m_pMyEnumWbem);   
  835.         VariantInit(&MyVar);   
  836.         MyReturn=0;   
  837.         MyHResult=m_pMyEnumWbem->Next(WBEM_INFINITE,1,&m_pMyWbemObj,&MyReturn);   
  838.         if(SUCCEEDED(MyHResult)&&MyReturn>0)    
  839.             MyHResult=m_pMyWbemObj->Get(CComBSTR(MyItem),0,&MyVar,0,0);   
  840.         else    
  841.             return(MyData);   
  842.         MyData=TransferData(&MyVar);   
  843.         VariantClear(&MyVar);   
  844.         if(m_pMyEnumWbem)    
  845.             MyHResult=m_pMyEnumWbem->Release();   
  846.         if(m_pMyWbemObj)    
  847.             MyHResult=m_pMyWbemObj->Release();   
  848.         m_pMyEnumWbem=0;   
  849.         m_pMyWbemObj=0;   
  850.         return(MyData);   
  851.     }   
  852. };   
  853.    
  854. void CMyDlgExDlg::OnBnClickedButton33()   
  855. {//使用COM接口调用WMI查询数据信息   
  856.     CString MyData="CPU的描述信息是：";   
  857.     CMyWMI MyWmi;   
  858.     MyWmi.InitializeComInterface();   
  859.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","Description");   
  860.     if(!MyTip.IsEmpty())    
  861.     {   
  862.         MyData+=MyTip+"\r\n";   
  863.         MessageBox(MyData,"信息提示",0);   
  864.     }   
  865.     MyWmi.ReleaseComInterface();   
  866. }   
  867.    
  868. void CMyDlgExDlg::OnBnClickedButton34()   
  869. {//获取当前计算机CPU的名称信息   
  870.     CString MyData="当前计算机CPU的名称是：";   
  871.     CMyWMI MyWmi;   
  872.     MyWmi.InitializeComInterface();   
  873.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","Name");   
  874.     if(!MyTip.IsEmpty())    
  875.     {   
  876.         MyData+=MyTip+"\r\n";   
  877.         MessageBox(MyData,"信息提示",0);   
  878.     }   
  879.     MyWmi.ReleaseComInterface();   
  880. }   
  881.    
  882. void CMyDlgExDlg::OnBnClickedButton35()   
  883. {//获取当前计算机CPU的地址宽度   
  884.     CString MyData="当前计算机CPU的地址宽度是：";   
  885.     CMyWMI MyWmi;   
  886.     MyWmi.InitializeComInterface();   
  887.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","AddressWidth");   
  888.     if(!MyTip.IsEmpty())    
  889.     {   
  890.         MyData+=MyTip+"\r\n";   
  891.         MessageBox(MyData,"信息提示",0);   
  892.     }   
  893.     MyWmi.ReleaseComInterface();   
  894. }   
  895.    
  896. void CMyDlgExDlg::OnBnClickedButton36()   
  897. {//获取当前计算机CPU的数据宽度   
  898.     CString MyData="当前计算机CPU的数据宽度是：";   
  899.     CMyWMI MyWmi;   
  900.     MyWmi.InitializeComInterface();   
  901.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","DataWidth");   
  902.     if(!MyTip.IsEmpty())    
  903.     {   
  904.         MyData+=MyTip+"\r\n";   
  905.         MessageBox(MyData,"信息提示",0);   
  906.     }   
  907.     MyWmi.ReleaseComInterface();   
  908. }   
  909.    
  910. void CMyDlgExDlg::OnBnClickedButton37()   
  911. {//获取当前计算机CPU的当前时钟速度   
  912.     CString MyData="当前计算机CPU的当前时钟速度是：";   
  913.     CMyWMI MyWmi;   
  914.     MyWmi.InitializeComInterface();   
  915.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","CurrentClockSpeed");   
  916.     if(!MyTip.IsEmpty())    
  917.     {   
  918.         MyData+=MyTip+"\r\n";   
  919.         MessageBox(MyData,"信息提示",0);   
  920.     }   
  921.     MyWmi.ReleaseComInterface();   
  922. }   
  923.    
  924. void CMyDlgExDlg::OnBnClickedButton38()   
  925. {//获取当前计算机CPU的最大时钟速度   
  926.     CString MyData="当前计算机CPU的最大时钟速度是：";   
  927.     CMyWMI MyWmi;   
  928.     MyWmi.InitializeComInterface();   
  929.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","MaxClockSpeed");   
  930.     if(!MyTip.IsEmpty())    
  931.     {   
  932.         MyData+=MyTip+"\r\n";   
  933.         MessageBox(MyData,"信息提示",0);   
  934.     }   
  935.     MyWmi.ReleaseComInterface();   
  936. }   
  937.    
  938. void CMyDlgExDlg::OnBnClickedButton39()   
  939. {//获取当前计算机CPU的外部时钟速度   
  940.     CString MyData="当前计算机CPU的外部时钟速度是：";   
  941.     CMyWMI MyWmi;   
  942.     MyWmi.InitializeComInterface();   
  943.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","ExtClock");   
  944.     if(!MyTip.IsEmpty())    
  945.     {   
  946.         MyData+=MyTip+"\r\n";   
  947.         MessageBox(MyData,"信息提示",0);   
  948.     }   
  949.     MyWmi.ReleaseComInterface();   
  950. }   
  951.    
  952. void CMyDlgExDlg::OnBnClickedButton40()   
  953. {//获取当前计算机CPU的加载百分比   
  954.     CString MyData="当前计算机CPU的加载百分比是：";   
  955.     CMyWMI MyWmi;   
  956.     MyWmi.InitializeComInterface();   
  957.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","LoadPercentage");   
  958.     if(!MyTip.IsEmpty())    
  959.     {   
  960.         MyData+=MyTip+"\r\n";   
  961.         MessageBox(MyData,"信息提示",0);   
  962.     }   
  963.     MyWmi.ReleaseComInterface();   
  964. }   
  965.    
  966. void CMyDlgExDlg::OnBnClickedButton41()   
  967. {//获取当前计算机CPU的设备制造商   
  968.     CString MyData="当前计算机CPU的设备制造商是：";   
  969.     CMyWMI MyWmi;   
  970.     MyWmi.InitializeComInterface();   
  971.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","Manufacturer");   
  972.     if(!MyTip.IsEmpty())    
  973.     {   
  974.         MyData+=MyTip+"\r\n";   
  975.         MessageBox(MyData,"信息提示",0);   
  976.     }   
  977.     MyWmi.ReleaseComInterface();   
  978. }   
  979.    
  980. void CMyDlgExDlg::OnBnClickedButton42()   
  981. {//获取当前计算机CPU的二级缓存尺寸   
  982.     CString MyData="当前计算机CPU的二级缓存尺寸是：";   
  983.     CMyWMI MyWmi;   
  984.     MyWmi.InitializeComInterface();   
  985.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","L2CacheSize");   
  986.     if(!MyTip.IsEmpty())    
  987.     {   
  988.         MyData+=MyTip+"\r\n";   
  989.         MessageBox(MyData,"信息提示",0);   
  990.     }   
  991.     MyWmi.ReleaseComInterface();       
  992. }   
  993.    
  994. void CMyDlgExDlg::OnBnClickedButton43()   
  995. {//获取当前计算机CPU的二级缓存速度   
  996.     CString MyData="当前计算机CPU的二级缓存速度是：";   
  997.     CMyWMI MyWmi;   
  998.     MyWmi.InitializeComInterface();   
  999.     CString MyTip=MyWmi.GetQueryData("SELECT * FROM Win32_Processor","L2CacheSpeed");   
  1000.     if(!MyTip.IsEmpty())    
  1001.     {   
  1002.         MyData+=MyTip+"\r\n";   
  1003.         MessageBox(MyData,"信息提示",0);   
  1004.     }   
  1005.     MyWmi.ReleaseComInterface();       
  1006. }   
  1007.    
  1008.    
  1009. void CMyDlgExDlg::OnBnClickedButton44()   
  1010. {   
  1011.     CString MyCommand="cmd /c wmic useraccount get name > c:\\MyWMIC.txt";   
  1012.     WinExec(MyCommand,SW_HIDE);   
  1013.     Sleep(1000);   
  1014.     CString MyFile="c:\\MyWMIC.txt";   
  1015.     SHELLEXECUTEINFO MyExe;                 
  1016.     memset (&MyExe, 0, sizeof(MyExe)) ;   
  1017.     MyExe.cbSize=sizeof (MyExe) ;   
  1018.     MyExe.lpVerb="open" ;   
  1019.     MyExe.lpFile=MyFile;   
  1020.     MyExe.lpParameters=NULL;   
  1021.     MyExe.fMask=SEE_MASK_NOCLOSEPROCESS ;   
  1022.     MyExe.nShow=SW_SHOWDEFAULT ;   
  1023.     ShellExecuteEx (&MyExe);           
  1024. }   
woshidaniu
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C++】WMI获取系统硬件信息(CPU/DISK/NetWork etc)
李宁宁
05-14 9357
官网找到一个例子，根据例子修改下可以获取很多信息 #define _WIN32_DCOM #include using namespace std; #include #include #pragma comment(lib, "wbemuuid.lib") int main(int argc, char **argv) { HRESULT hres; // Step
学习笔记 -- 使用WMI获得系统信息
峰子的专栏
12-03 4665
学习笔记 -- 使用WMI获得系统信息WMI是Windows 2K/XP管理系统的核心。WMI以CIMOM为基础，CIMOM即公共信息模型对象管理器（Common Information Model Object Manager），是一个描述操作系统构成单元的对象数据库，为MMC和脚本程序提供了一个访问操作系统构成单元的公共接口。有了WMI，工具软件和脚本程序访问操作系统的不同部分时不需要使用
通过WMI获取系统信息
thanklife的专栏
06-26 2506
要了解WMI，请查阅： http://www.microsoft.com/china/technet/community/scriptcenter/resources/wmifaq.mspx#EJC 。        WMI是一组COM对象，其接口比较多，详细请参考： http://msdn.microsoft.com/library/default.asp?url=/library/en-
wmicGet:使用 WMIC 在 Windows 上获取计算机和操作系统信息-matlab开发
05-30
wmicGet返回Windows平台上的计算机和操作系统信息。 wmicGet 是调用 Windows 管理规范命令行 (WMIC) 的包装函数。 wmicGet 还可以使用 WQL 语法的“where”子句来执行更高级的查询。 例子： infos = wmicGet('cpu'); infos = wmicGet('win32_logicaldisk', {'DeviceID' 'FreeSpace' 'Size'}, ... '哪里',{'' 'DeviceID' 'C:' true ; '或' '设备 ID' 'D:' 真}) 有关更多示例和指向 Microsoft 文档的链接，请参阅 wmicGet.m 标头。
C# 调用WMI 获取系统信息
01-09
总的来说，通过C#调用WMI获取系统信息是Windows开发中的一个重要技能，它可以帮助开发者或系统管理员获取详细的系统状态，进行故障排查、性能监控和资源管理。了解并熟练运用这一技术对于提升工作效率和解决问题具有...
C# 调用WMI 获取系统信息，源代码及示例。
01-09
本篇文章将详细解释如何使用C#调用WMI获取系统信息，并提供源代码和示例。 首先，理解WMI：它是微软的管理规范，允许应用程序通过标准接口查询和更改Windows系统状态。WMI提供了丰富的类库，这些类库对应于系统中的...
wmi获取系统信息
05-12
get bios info get desktop info get disk driver info get display controller info get display driver info get envirment string get keyboard info get main board info get Monitor ...
VC利用WMI获取系统信息..
06-05
VC利用WMI获取系统信息..包括BIOS,CPU,显卡,声卡,硬盘,内存的信息
使用WMI获取系统信息
12-16
使用WMI，开发者可以轻松地获取系统信息，如硬件配置、操作系统版本、运行的服务、网络状态等。 WMI的核心是其类库，这些类代表了系统中的对象，如计算机、进程、服务、设备驱动等。每个类都有自己的属性和方法，...
利用WMI获得系统所有用户
05-15
利用WMI获得用户 利用WMI获得用户 利用WMI获得用户 利用WMI获得用户 利用WMI获得用户 利用WMI获得用利用WMI获得用户 利用WMI获得用户 户
利用WMI获取系统的软硬件信息的学习与总结
Feng______的专栏
06-18 2354
文章学习于 http://blog.csdn.net/breaksoftware/article/details/8439975 感谢博主。
VC6应用WMI获取系统信息
oju887jn
01-20 209
VC6应用WMI获取系统信息 2011年05月02日 　　花费两天左右时间，总算可以在VC6下使用WMI技术了，现将遇到的问题及解决方法记录一下。 　　起因是为了获取系统的硬件信息，经查阅可以使用WMI技术来实现，于CodeProject网站上下载了vc6使用WMI的示例程序，结果发现编译不成功。 　　出错信息如下： fatal error C1083: Cannot open ...
常用WMI获取系统信息的代码
weixin_30699465的博客
09-24 125
usingSystem;usingSystem.Collections.Generic;usingSystem.Text;usingSystem.Management;usingSystem.Net.Sockets;usingSystem.Net;namespaceSystemInfo{classProgram{staticvoidMa...
通过wmic监控Windows系统信息
DBA大董的博客
03-13 6177
通过wmic监控Windows系统信息1、wmic 格式化输出2、获取服务器信息3、获取系统信息4、获取硬盘信息5、获取磁盘剩余空间6、获取文件共享7、获取网络共享信息8、获取CPU信息9、获取内存硬件信息10、获取内存使用信息11、获取域控信息12、获取进程信息 1、wmic 格式化输出 wmic ALIAS get property,property /format:CSV 2、获取服务器信息 wmic baseboard get manufacturer,product Manufacturer
win32 wmi编程获取系统信息
Gone_HuiLin的博客
12-02 712
//GetSysInfo.h #pragma once #include class GetSysInfo { public: GetSysInfo(void); ~GetSysInfo(void); public: /********获取操作系统版本，Service pack版本、系统类型************/ void GetOSVersion(CString &strOSV
wmic 常用的获取计算机信息的命令
为了生活，不得不努力奋斗！
02-20 705
获取主板信息：wmic baseboard get product,manufacturer,version。获取显卡信息：wmic path Win32_VideoController get name。wmic computersystem get model # 获取计算机的型号。wmic bios get serialnumber # 获取主板的序列号。wmic cpu get name # 获取CPU的名字。获取cpu信息：wmic cpu get name。
wmic 获得系统硬件信息
weixin_30566111的博客
07-13 207
wmic扩展了wmi系统管理指令，提供了命令行接口和批处理执行系统管理的工具。通过别名机制将命令转为对wmi命名空间的操作 1.获得cpu信息 　 2.获得cpu 核数 3.获得内存条信息 转载于:https://www.cnblogs.com/zhengwenqiang/p/7159326.html...
QT获取电脑系统，主板型号，CPU型号，硬盘型号，内存大小等相关信息（一）通过CMD和WMIC命令行的方式
最新发布
qq_35554617的博客
07-05 1932
QT通过CMD和WMIC命令行的方式获取电脑系统，主板型号，CPU型号，硬盘型号,主板型号，内存大小等相关信息
python wmi获取计算机硬件信息
05-13
利用Python WMI可以获取操作系统，服务，进程，事件等计算机信息，并且还可以获取计算机硬件信息。 Python WMI可以访问计算机的BIOS信息，包括电源状态、信息、版本等。还可以访问CPU信息，包括名称、架构、频率等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值