WMI via C++: 一个C++风格的复杂性处理实例

WMI简介

按照wikipedia的解释，WMI是Windows驱动模型的扩展集合，通过工具化的组件提供了操作系统的接口。WMI本身是基于Webm和CIM工业标准的管理架构Microsoft实现。相对于程序员，系统管理员可能更熟悉这些接口。WMI通过一种一致的面向对象的封装，提供了绝大部分操作系统核心功能的支持，可以直接使用在Windows 2000 SP4以上的机器中。对于缺省不支持WMI的OS，如Windows 2000之前的操作系统，有独立的安装包可以下载。

因为WMI主要是针对系统管理的，稍微了解一下你就可以知道，WMI似乎“生来”就对各种脚本语言友好。更新的powershell就不说了，VBscript一直使用WMI的最佳选择。C#的支持也似乎不错。

 

WMI基础 

上面已经提到，WMI是微软的CIM工业标准的实现，提供了对Windows进行管理的完备详尽的支持。对比程序员来说，Windows系统管理员可能更熟悉Windows的WMI接口，因为这是使用脚本化的基础自动化日常管理任务的最好手段。Windows程序员一般非常熟悉win32 API并且针对此编程。不幸的是，有一些Windows服务并不提供基于Win32 API的接口支持，如HyperV。关于具体的WMI相关的信息，请参阅MSDN文档。简单说来，WMI提供了：

1. 完整的基于对象的管理模式。所有的可管理项都被抽象成具体的对象。而这些对象的模板被称为类

2. 类可以从其他的类中继承。

3. 一致的对象访问方法。

 

为了有效地熟悉WMI，建议安装WMIStudio工具，可以在网上直接下载到。

 

WMI对C/C++实现者的挑战

由于WMI支持的编程模型的限制，哪怕是一个简答查询，典型的情况也需要几十行代码，更不要说函数调用。MSDN有一些WMI的使用例子，你可以看出来，使用C++调用WMI简直就是复杂的要死。如果说C++要调用WMI就必须这么复杂的话，我们只能说C++根本就不适合这里。不过，C++的长处是为可能的应用提供基本的支持。在彻底放弃之前，我们还是试一试简单的C++封装能不能有效简化WMI的使用。

我们这里先列出使用WMI需要处理的的可能挑战（最好对比个MSDN的例子来看）

1. COM支持；

2. WMI locator。也就是说执行WMI命令的实体代理，可以是本地的，也可以是远端的；

3. WMI变量。WMI吧所有的支持的变量类型封装到VARIANT结构中，对于不同的类型，提供不同的宏来访问；

4. WMI对象。对于任何的WMI实体，都对应于一个COM对象；

5. 对象属性。对象可以有一个或者多个属性；

6. 对于函数调用，则有输入对象和输出对象的处理；

7. WMI查询，对象方法调用

8. 异步WMI调用的处理

 

使用C++封装WMI调用

1. COM执行环境的封装。使用RAII技术，可以简单地实现COM执行环境的封装。这样在程序的入口处调用enable_COM_support()就可以了。

// the COM initialize and finalization, had better use as a singleton class com_env { friend void enable_COM_support(DWORD); com_env(DWORD initFlag) { HRESULT hres = CoInitializeEx(0, initFlag); if (FAILED(hres)) throw WIN_STD_EXCEPTION_WITH_ERR(hres); hres = CoInitializeSecurity( NULL, -1, // COM negotiates service NULL, // Authentication services NULL, // Reserved RPC_C_AUTHN_LEVEL_DEFAULT, // authentication RPC_C_IMP_LEVEL_IMPERSONATE, // Impersonation NULL, // Authentication info EOAC_NONE, // Additional capabilities NULL // Reserved ); if (hres != S_OK && hres != RPC_E_TOO_LATE) { CoUninitialize(); throw WIN_STD_EXCEPTION_WITH_ERR(hres); } } ~com_env() { CoUninitialize(); } }; // standalone of COM support inline void enable_COM_support(DWORD initFlag = COINIT_MULTITHREADED) { static com_env env(initFlag); } 

 

2. WMI执行代理。在创建执行代理之前，我们必须创建WMI服务器对象。因为我们同时要保证执行代理可以方便地传来传去，我们对其内部引用的对象使用了基于引用计数的自动销毁策略。又是RAII:)

#pragma comment(lib, "wbemuuid.lib") // WMI locator, represent a place that WMI query command can send to, either local or remote host class wbem_locator { class wbem_server { util::ref_count _ref; IWbemServices* _svr; public: wbem_server(IWbemServices* svr = 0) : _svr(svr) {} ~wbem_server() { if (_ref.only() && _svr) _svr->Release(); } wbem_server& operator = (const wbem_server& rhs) { if (this == &rhs) return *this; if (_ref.attach(rhs._ref) && _svr) _svr->Release(); _svr = rhs._svr; return *this; } operator IWbemServices* () const { return _svr; } }; struct the_locator { IWbemLocator* _locator; the_locator() { HRESULT hres = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID*)&_locator); if (FAILED(hres)) throw WIN_STD_EXCEPTION_WITH_ERR(hres); } ~the_locator() { _locator->Release(); } wbem_server connect_to(_bstr_t ns, _bstr_t user, _bstr_t password, _bstr_t locale) { IWbemServices* svr = 0; HRESULT hres = _locator->ConnectServer(ns, user, password, locale, NULL, 0, 0, &svr); if (FAILED(hres)) throw WIN_STD_EXCEPTION_WITH_ERR(hres); return wbem_server(svr); } }; friend class server_proxy; public: // If the user name is from a domain different from the current domain, the string may // contain the domain name and user name separated by a backslash: "Domain//UserName". // You can use the user principal name (UPN) format, which is Username@DomainName to // specify the strUser (not apply Windows 2000 and Windows NT 4.0) wbem_locator(const wchar_t* host, const wchar_t* user, const wchar_t* password, const wchar_t* locale, const wchar_t* path) : _host(host), _user(user), _password(password), _locale(locale), _path(path) { the_locator locator; _server = locator.connect_to( "////" + _bstr_t(_host) + _path, // path _bstr_t(_user? _user : (const wchar_t*)0), // User name _bstr_t(_password? _password : (const wchar_t*)0), // User password _bstr_t(_locale? _locale : (const wchar_t*)0) // Locale ); HRESULT hres = CoSetProxyBlanket( _server, // the proxy to set RPC_C_AUTHN_WINNT, // authentication service RPC_C_AUTHZ_NONE, // authorization service NULL, // Server principal name RPC_C_AUTHN_LEVEL_CALL, // authentication level RPC_C_IMP_LEVEL_IMPERSONATE, // impersonation level NULL, // client identity EOAC_NONE // proxy capabilities ); if (FAILED(hres)) throw WIN_STD_EXCEPTION_WITH_ERR(hres); } IWbemServices* get_server() const { return _server; } private: const wchar_t* _host; const wchar_t* _user; const wchar_t* _password; const wchar_t* _locale; const wchar_t* _path; wbem_server _server; }; 

注意，wbem_server和the_locator是两个内部类，因为客户代码从来不用关心这些。对于他们，有一个执行代理就足够了。有了这个实现，我们就可以提供简单的辅助实现，直接返回本地的或者远程的执行代理。

inline wbem_locator local_host(const wchar_t* path = L"//root//cimv2") { assert(path); return wbem_locator(L".", 0, 0, 0, path); } inline wbem_locator local_host_with_credential(const wchar_t* user, const wchar_t* pwd, const wchar_t* path = L"//root//cimv2") { assert(user && pwd && path); return wbem_locator(L".", user, pwd, 0, path); } inline wbem_locator remote_host(const wchar_t* host, const wchar_t* path = L"//root//cimv2") { assert(host && path); return wbem_locator(host, 0, 0, 0, path); } inline wbem_locator remote_host_with_credential(const wchar_t* host, const wchar_t* user, const wchar_t* pwd, const wchar_t* path = L"//root//cimv2") { assert(host && user && pwd && path); return wbem_locator(host, user, pwd, 0, path); }  

 

3. 其实，对WMI变量的封装不是必须的，但是有几个我们认为重要的原因促使我们这样做：1. WMI变量使用是需要首先构造，而使用后需要释放；2. 使用WMI变量需要使用大量的宏，难以保证类型安全。基于此，我们实现了WMI变量的封装，同样，还是以RAII基础为基础。

// simple RAII wrapper for VARIANT class var_t : public VARIANT { // no copy and assignment supported var_t(const var_t&); var_t& operator = (const var_t&); public: var_t() { VariantInit(this); } ~var_t() { VariantClear(this); } bool is_null() const { return V_VT(this) == VT_EMPTY || V_VT(this) == VT_NULL; } byte byte_v() const { assert(V_VT(this) == VT_UI1); return V_UI1(this); } bool bool_v() const { assert(V_VT(this) == VT_BOOL); return V_BOOL(this) == VARIANT_TRUE; } int16 short_v() const { assert(V_VT(this) == VT_I2); return V_I2(this); } uint16 ushort_v() const { assert(V_VT(this) == VT_UI2); return V_UI2(this); } int32 long_v() const { assert(V_VT(this) == VT_I4); return V_I4(this); } uint32 ulong_v() const { assert(V_VT(this) == VT_UI4); return V_UI4(this); } int64 llong_v() const { assert(V_VT(this) == VT_I8); return V_I8(this); } uint64 ullong_v() const { assert(V_VT(this) == VT_UI8); return V_UI8(this); } float float_v() const { assert(V_VT(this) == VT_R4); return V_R4(this); } double double_v() const { assert(V_VT(this) == VT_R8); return V_R8(this); } _bstr_t string_v() const { assert(V_VT(this) == VT_BSTR); return V_BSTR(this); } IUnknown* unknown_v() const { assert(V_VT(this) == VT_UNKNOWN); return V_UNKNOWN(this);} SYSTEMTIME date_v() const { assert(V_VT(this) == VT_DATE); SYSTEMTIME st; VariantTimeToSystemTime(V_DATE(this), &st); return st; } // array value access #define array_v(name_, otype_, type_, ref_) / std::vector<otype_> name_() const/ {/ assert(V_VT(this) == (type_ | VT_ARRAY));/ std::vector<otype_> values;/ SAFEARRAYBOUND sab = parray->rgsabound[0];/ for (LONG i = sab.lLbound; i < (LONG)sab.cElements; ++i)/ {/ VARIANT Value;/ long Index[1];/ Index[0] = i;/ SafeArrayPtrOfIndex(parray, Index, &Value.byref);/ values.push_back((ref_(&Value))[0]);/ }/ return values;/ }/ array_v(string_array_v, _bstr_t, VT_BSTR, V_BSTRREF); array_v(iunknown_array_v, IUnknown*, VT_UNKNOWN, V_UNKNOWNREF); array_v(uint32_array_v, uint32, VT_I4, V_UI4REF); array_v(byte_array_v, byte, VT_UI1, V_UI1REF); #undef array_v std::wstring get_value_in_wstring() { std::wstringstream wss; switch (V_VT(this)) { case CIM_ILLEGAL: wss << L"<Illegal>"; break; case VT_NULL: case CIM_EMPTY: wss << L"<Empty>"; break; case CIM_SINT8: wss << V_I1(this); break; case CIM_UINT8: wss << V_UI1(this); break; case CIM_SINT16: wss << V_I2(this); break; case CIM_UINT16: wss << V_UI2(this); break; case CIM_SINT32: wss << V_I4(this); break; case CIM_UINT32: wss << V_UI4(this); break; case CIM_SINT64: wss << V_I8(this); break; case CIM_UINT64: wss << V_UI8(this); break; case CIM_REAL32: wss << V_R4(this); break; case CIM_REAL64: wss << V_R8(this); break; case CIM_BOOLEAN: wss << (V_BOOL(this) ? L"true" : L"false"); break; case CIM_STRING: case CIM_DATETIME: case CIM_REFERENCE: case CIM_CHAR16: wss << V_BSTR(this); break; case CIM_OBJECT: wss << L"<Object>"; break; default: { if (V_VT(this) > CIM_FLAG_ARRAY) { assert(SafeArrayGetDim(this->parray) == 1); wss << L"ARRAY("; SAFEARRAYBOUND* sab = &this->parray->rgsabound[0]; for (LONG i = sab->lLbound; i < (LONG)sab->cElements; ++i) { VARIANT Value; long Index[1]; Index[0] = i; SafeArrayPtrOfIndex(this->parray, Index, &Value.byref); if (i > this->parray->rgsabound[0].lLbound) wss << L", "; switch (V_VT(this) & ~CIM_FLAG_ARRAY) { case CIM_SINT8: wss << (V_I1REF(&Value))[0]; break; case CIM_UINT8: wss << (V_UI1REF(&Value))[0]; break; case CIM_SINT16: wss << (V_I2REF(&Value))[0]; break; case CIM_UINT16: wss << (V_UI2REF(&Value))[0]; break; case CIM_SINT32: wss << (V_I4REF(&Value))[0]; break; case CIM_UINT32: wss << (V_UI4REF(&Value))[0]; break; case CIM_SINT64: wss << (V_I8REF(&Value))[0]; break; case CIM_UINT64: wss << (V_UI8REF(&Value))[0]; break; case CIM_REAL32: wss << (V_R4REF(&Value))[0]; break; case CIM_REAL64: wss << (V_R8REF(&Value))[0]; break; case CIM_BOOLEAN: wss << ((V_BOOLREF(&Value))[0] ? L"true" : L"false"); break; case CIM_STRING: case CIM_DATETIME: case CIM_REFERENCE: case CIM_CHAR16: wss << (V_BSTRREF(&Value))[0]; break; } } wss << L")"; } else { wss << L"<Unknown Type>"; } } } return wss.str(); } };  

其中我们使用了一个难看的宏来消除访问不同类型数组是导致的代码重复。需要注意的是，这个封装不是完备的，仅仅实现了常用的类型。如果需要增加新的类型，只需按照类似的模式加入即可。

 

4. WMI对象。和其他的WMI编程使用的实例一样，WMI对象也是基于RAII的，我们需要频繁地传递WMI对象，也加上了引用计数的支持。

// the WMI object wrapper class obj_handle { friend class properies; friend class in_param; public: obj_handle(IWbemClassObject* obj = 0) : _obj(obj) {}; ~obj_handle() { if (_ref.only() && _obj) _obj->Release(); } obj_handle& operator = (const obj_handle& rhs) { if (this == &rhs) return *this; if (_ref.attach(rhs._ref) && _obj) _obj->Release(); _obj = rhs._obj; return *this; } operator bool() const { return _obj != 0; } operator IWbemClassObject* () const { return _obj; } IWbemClassObject* raw_obj() { return _obj; } obj_handle clone() { IWbemClassObject* cpy; HRESULT hr = _obj->SpawnInstance(0, &cpy); if (SUCCEEDED(hr)) return obj_handle(cpy); else throw WIN_STD_EXCEPTION_WITH_ERR(hr); } _bstr_t path() const { var_t v; if (get_property(path_property_name(), v)) return v.string_v(); return _bstr_t(); } bool get_property(const wchar_t* name, var_t& var) const { if (!_obj) return false; HRESULT hr = _obj->Get(name, 0, &var, 0, 0); return SUCCEEDED(hr); } protected: virtual const wchar_t* path_property_name() const { return L"__PATH"; } private: IWbemClassObject* _obj; util::ref_count _ref; }; 

 

5. 对象属性的封装。对象可能有对各属性，所以我们提供一个属性集类，通过它可以遍历对象的所有的属性。

// the WMI object properties class properies { public: struct prop_item { std::wstring _name; std::wstring _value; CIMTYPE _type; }; properies(obj_handle obj) : _obj(obj), _done(true) {} ~properies() { if (!_done) _obj._obj->EndEnumeration(); } prop_item start() { if (!_done) _obj._obj->EndEnumeration(); _obj._obj->BeginEnumeration(0); _done = false; return get_next(); } prop_item next() { return get_next(); } bool is_done() const { return _done; } private: obj_handle _obj; bool _done; prop_item get_next() { BSTR name = 0; var_t value; prop_item item; if (SUCCEEDED(_obj._obj->Next(0, &name, &value, &item._type, 0)) && name) { item._name = name; SysFreeString(name); item._value = value.get_value_in_wstring(); } else _done = true; return item; } };  

 

6. 函数调用，我们封装了IN和OUT参数如下：

// IN parameter for WMI calling class in_param { friend class server_proxy; _bstr_t _path; _bstr_t _method_name; obj_handle _wbem_obj; // SAFEARRAY wrapper class bstr_1D_safe_array { size_t _size; SAFEARRAY* _sa; std::vector<BSTR> _sys_alloced; bstr_1D_safe_array(const bstr_1D_safe_array&); bstr_1D_safe_array& operator =(const bstr_1D_safe_array&); public: bstr_1D_safe_array(size_t size) : _size(size) { SAFEARRAYBOUND sab; sab.lLbound = 0; sab.cElements = static_cast<ULONG>(_size); _sa = SafeArrayCreate(VT_BSTR, 1, &sab); if (!_sa) throw std::exception("fail to call SafeArrayCreate"); } ~bstr_1D_safe_array() { std::for_each(_sys_alloced.begin(), _sys_alloced.end(), std::ptr_fun(SysFreeString)); SafeArrayDestroy(_sa); } size_t size() const { return _size; } void set_value(size_t index, const BSTR& value) { assert(index < _size); var_t var; V_VT(&var) = VT_BSTR; V_BSTR(&var) = ::SysAllocString(value); LONG idx = static_cast<LONG>(index); HRESULT hr = SafeArrayPutElement(_sa, &idx, V_BSTR(&var)); if (FAILED(hr)) throw std::exception("fail to call SafeArrayPutElement"); } SAFEARRAY* get_raw() { return _sa; } }; public: in_param(const obj_handle& param, const wchar_t* path = 0, const wchar_t* name = 0) : _wbem_obj(param), _path(path), _method_name(name) {} void put_value(const wchar_t* key, long value) { _variant_t var(value); HRESULT hr = _wbem_obj.raw_obj()->Put(key, 0, &var, 0); if (FAILED(hr)) throw WIN_STD_EXCEPTION_WITH_ERR(hr); } void put_value(const wchar_t* key, const _bstr_t& value) { _variant_t var(value); HRESULT hr = _wbem_obj.raw_obj()->Put(key, 0, &var, 0); if (FAILED(hr)) throw WIN_STD_EXCEPTION_WITH_ERR(hr); } void put_value(const wchar_t* key, const std::vector<_bstr_t>& value) { bstr_1D_safe_array sa(value.size()); for (size_t i = 0; i < sa.size(); ++i) sa.set_value(i, value[i]); var_t var; V_VT(&var) = VT_BSTR | VT_ARRAY; V_ARRAY(&var) = sa.get_raw(); HRESULT hr = _wbem_obj.raw_obj()->Put(key, 0, &var, 0); if (FAILED(hr)) throw WIN_STD_EXCEPTION_WITH_ERR(hr); // fix 64bit OS crash issue V_VT(&var) = VT_EMPTY; V_ARRAY(&var) = 0; } void put_value(const wchar_t* key, BYTE* value, int length) { SAFEARRAYBOUND rgsabound[1]; rgsabound[0].lLbound = 0; rgsabound[0].cElements = (ULONG) length; SAFEARRAY* sa = SafeArrayCreate(VT_UI1, 1, rgsabound); if (sa == NULL) return; for (LONG i=0; i<length; i++) { BYTE val = value[i]; HRESULT hr = SafeArrayPutElement(sa, &i, static_cast<void*>(&val) ); if (FAILED(hr)) break; } var_t var; V_VT(&var) = VT_UI1 | VT_ARRAY; V_ARRAY(&var) = sa; HRESULT hr = _wbem_obj.raw_obj()->Put(key, 0, &var, 0); if (FAILED(hr)) throw WIN_STD_EXCEPTION_WITH_ERR(hr); // fix 64bit OS crash issue V_VT(&var) = VT_EMPTY; V_ARRAY(&var) = 0; } _bstr_t method_name() const { return _method_name; } _bstr_t object_path() const { return _path; } obj_handle object() const { return _wbem_obj; } operator const obj_handle&() const { return _wbem_obj; } }; // OUT parameter for WMI calling class out_param { obj_handle _wbem_obj; server_proxy* _proxy; _bstr_t _job_path; long _ret; public: out_param(obj_handle param, server_proxy* proxy) : _wbem_obj(param), _proxy(proxy) { var_t v; if (_wbem_obj && _wbem_obj.get_property(L"ReturnValue", v)) { if (V_VT(&v) == VT_BOOL) _ret = (v.bool_v() == true? 0 : 1); else _ret = v.long_v(); if (!succeed() && _wbem_obj.get_property(L"Job", v) && !v.is_null()) _job_path = v.string_v(); } else { // "no Return Value property" _ret = 0; } } obj_handle object() const { return _wbem_obj; } bool succeed() const { return _ret == 0; } bool in_process() const { return _ret == 4096; } long return_code() const { return _ret; } _bstr_t job_path() const { return _job_path; } bool wait_job_done() const; operator bool() const { if (succeed()) return true; else if (in_process()) return wait_job_done(); else return false; } };  

 

7. 有了上述的支持，WMI查询和调用就可以实现了，下面是代码：

// WMI server base class // user need derive from this class and specify the WMI class name though override member // get_service_class() class server_proxy { typedef std::map<std::wstring, std::wstring> filter_t; struct wmi_enumerator { IEnumWbemClassObject* _enumerator; wmi_enumerator(IWbemServices* svr, const bstr_t& query) : _enumerator(0) { HRESULT hres = svr->ExecQuery( bstr_t("WQL"), query, WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &_enumerator); if (FAILED(hres)) throw WIN_STD_EXCEPTION_WITH_ERR(hres); } ~wmi_enumerator() { if (_enumerator) _enumerator->Release(); } void restart() { _enumerator->Reset(); } obj_handle next() { ULONG uReturn = 0; IWbemClassObject* obj = 0; HRESULT hres = _enumerator->Next(WBEM_INFINITE, 1, &obj, &uReturn); if (hres != WBEM_S_NO_ERROR || uReturn == 0) obj = 0; return obj_handle(obj); } }; public: server_proxy(wbem_locator loc) : _loc(loc), _enumerator(0) {} virtual ~server_proxy() { delete _enumerator; } void start() { if (_enumerator) delete _enumerator; std::wstringstream qry; qry << get_query(); std::wstring cond = get_condition(); if (cond.size() > 0) qry << L" where " << cond; _enumerator = new wmi_enumerator(_loc.get_server(), bstr_t(qry.str().c_str())); } obj_handle next() { if (_enumerator) return _enumerator->next(); else return obj_handle(); } void set_equal_filter(const wchar_t* key, const wchar_t* value) { assert(key && value); _filter[key] = value; } void set_match_filter(const wchar_t* key, const wchar_t* value) { assert(key && value); _filter_match[key] = value; } in_param get_method_param(const wchar_t* method, const obj_handle& the_obj = obj_handle()) { IWbemClassObject* in_def = 0; IWbemClassObject* out_def = 0; obj_handle the_class = get_obj_by_path(_loc, get_service_class()); HRESULT hr = the_class.raw_obj()->GetMethod(_bstr_t(method), 0, &in_def, &out_def); if (SUCCEEDED(hr)) { obj_handle in; if (in_def) { in = obj_handle(in_def).clone(); } _bstr_t path; if (the_obj) { path = the_obj.path(); } else { // get the first instance of this class, this will reset the enumerator start(); path = next().path(); _enumerator->restart(); } return in_param(in, path, method); } else throw WIN_STD_EXCEPTION_WITH_ERR(hr); } out_param invoke_method(const in_param& in) { IWbemClassObject* out = 0; HRESULT hr = _loc.get_server()->ExecMethod(in.object_path(), in.method_name(), 0, NULL, in.object(), &out, NULL); if (SUCCEEDED(hr)) return out_param(out, this); else throw WIN_STD_EXCEPTION_WITH_ERR(hr); } static obj_handle get_obj_by_path(const wbem_locator& loc, const wchar_t* obj_path) { IWbemClassObject* obj = 0; IWbemCallResult* result = 0; HRESULT hr = loc.get_server()->GetObject(_bstr_t(obj_path), WBEM_FLAG_RETURN_WBEM_COMPLETE, 0, &obj, &result); // if the calling failed, obj is set as NULL and we can handle this correctly if (SUCCEEDED(hr)) return obj_handle(obj); else throw WIN_STD_EXCEPTION_WITH_ERR(hr); } wbem_locator get_locator() const { return _loc; } static _bstr_t object_2_xml(const obj_handle& obj) { wbem_obj_in_xml::wbem_context context; context.include_qualifiers(true); context.include_class_origin(true); context.path_level(0); context.exclude_system_properties(false); return wbem_obj_in_xml(context).to_xml(obj); } protected: virtual std::wstring get_query() const { std::wstringstream qry; qry << L"select * from " << get_service_class(); return qry.str(); } virtual std::wstring get_condition() const { std::wstringstream ss; if (_filter.size() > 0) { for (filter_t::const_iterator i = _filter.begin(); i != _filter.end(); ++i) { if (ss.str().size() > 0) ss << L" and "; ss << i->first << L" = '" << i->second << L"'"; } } if (_filter_match.size() > 0) { for (filter_t::const_iterator i = _filter_match.begin(); i != _filter_match.end(); ++i) { if (ss.str().size() > 0) ss << L" and "; ss << i->first << L" like '%" << i->second << L"%'"; } } return ss.str(); } virtual bstr_t get_service_class() const = 0; virtual const wchar_t* category_name() const { return L"<unspecified>"; } private: wmi_enumerator* _enumerator; filter_t _filter; filter_t _filter_match; wbem_locator _loc; }; inline bool out_param::wait_job_done() const { assert(_ret == 4096); for(;;) { obj_handle job = server_proxy::get_obj_by_path(_proxy->get_locator(), _job_path); var_t v; if (job && job.get_property(L"JobState", v)) { long state = v.long_v(); if (state == 7) // Completed return true; else if (state == 3 || state == 4 || state == 6) // Starting or Running or Shutting Down Sleep(1000); else return false; } else return false; } }  

 

完了。很多代码，不是吗？，幸运的是，我们只需要写一次即可。

 

实例

这是使用上述代码的例子。

class TerminalServiceSetting : public server_proxy { public: TerminalServiceSetting() : server_proxy(local_host()) {} virtual bstr_t get_service_class() const { return bstr_t("Win32_TerminalServiceSetting"); } virtual const wchar_t* category_name() const { return L"Win32_TerminalServiceSetting"; } }; inline static void invoke_test(int argc, wchar_t* argv[]) { UNREFERENCED_PARAMETER(argc); UNREFERENCED_PARAMETER(argv); TerminalServiceSetting tss; std::cout << "Before set: " ; tss.start(); while (obj_handle obj = tss.next()) { var_t v; if (obj.get_property(L"AllowTSConnections", v)) { std::cout << v.long_v() << endl; break; } } in_param in = tss.get_method_param(L"SetAllowTSConnections"); in.put_value(L"AllowTSConnections", 1); out_param out = tss.invoke_method(in); if (out) std::cout << "Set remote connection succeed" << endl; std::cout << "After set: "; tss.start(); while (obj_handle obj = tss.next()) { var_t vt; if (obj.get_property(L"AllowTSConnections", vt)) { std::cout << vt.long_v() << endl; break; } } } 

 

注意，例子中硬编码了字串“Win32_TerminalServiceSetting”，这个是对应的WMI类的名字，这个是必须的。当然还有其他的方法可以消除这个限制，至少隐藏起来。

 

对比MSDN提供的代码，你会发现，使用我们封装后接口的代码少而且直观。Bjarne曾经说过4点学习C++应该关注的重点：问题域中最基本的对象；对象之间的关系；资源管理以及错误管理。完全可以用来检查这个实现。

 

注意，这只是日常工作中使用的对应于我们的需求的一个简明版本，还有调优的余地，也可能不能满足你的要求。但是通过这个例子，我想说明的是C++提供足够的强大的抽象机制和工具用来处理实现过程中遭遇的复杂性。C++程序员再也不用在使用WMI这一问题上羡慕脚本程序员了！