Tworzenie klasy bazowej usługi WMI

Artykuł
03/14/2025

Zalecanym sposobem utworzenia nowej klasy bazowej WMI dla dostawcy usługi WMI jest plik MOF (Managed Object Format). Możesz również utworzyć klasę bazową przy użyciu interfejsu API COM dla usługi WMI. Chociaż można utworzyć klasę bazową lub pochodną w skrypcie, bez dostawcy dostarczającego dane do klasy i jej podklas, klasa nie jest przydatna.

W tym temacie omówiono następujące sekcje:

tworzenie klasy bazowej przy użyciu MOF
tworzenie klasy bazowej przy użyciu języka C++
Tematy pokrewne

Tworzenie klasy bazowej przy użyciu narzędzia MOF

Klasy WMI zwykle opierają się na dziedziczeniu. Przed utworzeniem klasy bazowej sprawdź klasy Common Information Model (CIM) dostępne w rozproszonych grupach zadaniowych zarządzania (DMTF).

Jeśli wiele klas pochodnych będzie używać tych samych właściwości, umieść te właściwości i metody w klasie bazowej. Maksymalna liczba właściwości, które można zdefiniować w klasie WMI, wynosi 1024.

Podczas tworzenia klasy bazowej zapoznaj się z następującą listą wytycznych dotyczących nazw klas:

Użyj zarówno wielkich liter, jak i małych liter.
Rozpocznij nazwę klasy literą.
Nie używaj znaku podkreślenia na początku ani na końcu.
Zdefiniuj wszystkie pozostałe znaki jako litery, cyfry lub podkreślenia.
Użyj spójnej konwencji nazewnictwa.

Chociaż nie jest to konieczne, dobra konwencja nazewnictwa klasy to dwa składniki połączone podkreśleniami. Jeśli to możliwe, nazwa dostawcy powinna składać się z pierwszej połowy nazwy, a nazwa klasy opisowej powinna być drugą częścią.

Notatka

Nie można zmieniać klas podczas działania dostawców usług. Należy zatrzymać działanie, zmienić klasę, a następnie ponownie uruchomić usługę Windows Management. Wykrywanie zmiany klasy nie jest obecnie możliwe.

W moF utwórz klasę bazową, nazywając ją klasą słowem kluczowym, ale nie wskazując klasy nadrzędnej.

Aby utworzyć klasę bazową przy użyciu kodu MOF

Użyj słowa kluczowego klasy o nazwie nowej klasy, po którym następuje para nawiasów klamrowych i średnik. Dodaj właściwości i metody dla klasy między nawiasami klamrowymi. Podany jest poniższy przykład kodu.

W poniższym przykładzie kodu pokazano, jak należy zdefiniować klasę bazową.
```
class MyClass_BaseDisk
{
};
```
Poniższy przykład kodu przedstawia niepoprawną definicję klasy bazowej.
```
class MyClass_BaseDisk : CIM_LogicalDisk
{
};
```
Dodaj dowolne kwalifikatory klasy przed słowem kluczowym klasy, aby zmodyfikować sposób, w jaki klasa jest używana. Umieść kwalifikatory między nawiasami kwadratowymi. Aby uzyskać więcej informacji na temat kwalifikatorów do zmiany klas, zobacz Kwalifikatory WMI. Użyj kwalifikatora abstrakcyjnego, aby wskazać, że nie można bezpośrednio utworzyć wystąpienia tej klasy. Klasy abstrakcyjne są często używane do definiowania właściwości lub metod, które będą używane przez kilka klas pochodnych. Aby uzyskać więcej informacji, zobacz Tworzenie klasy pochodnej.

Poniższy przykład kodu definiuje klasę jako abstrakcyjną i definiuje dostawcę, który dostarczy dane. Kwalifikator ToSubClassflaworu wskazuje, że informacje w kwalifikatorze Provider są dziedziczone przez klasy pochodne.
```
[Abstract, Provider("MyProvider") : ToSubClass]
class MyClass_BaseDisk
{
};
```
Dodaj właściwości i metody klasy w nawiasach kwadratowych przed nazwą właściwości lub metody. Aby uzyskać więcej informacji, zobacz Dodawanie właściwości i Tworzenie metody. Te właściwości i metody można modyfikować przy użyciu kwalifikatorów MOF. Aby uzyskać więcej informacji, zobacz sekcję Dodawanie kwalifikatora.

Poniższy przykład kodu przedstawia sposób modyfikowania właściwości i metod za pomocą kwalifikatorów MOF.
```
[read : ToSubClass, key : ToSubClass ] string DeviceID;
  [read : ToSubClass] uint32 State;
  [read : ToSubclass, write : ToSubClass] uint64 LimitUsers;
```
Zapisz plik MOF z rozszerzeniem mof.
Zarejestruj klasę w usłudze WMI, uruchamiając Mofcomp.exe w pliku.

mofcomp.exenewmof.mof

Jeśli nie używasz przełącznika -N lub polecenia preprocesora #przestrzeni nazw pragma do określenia przestrzeni nazw, skompilowane klasy MOF będą przechowywane w głównej\domyślnej przestrzeni nazw w repozytorium. Aby uzyskać więcej informacji, zobacz mofcomp.

Poniższy przykład kodu łączy przykłady kodu MOF omówione w poprzedniej procedurze i pokazuje, jak utworzyć klasę bazową w przestrzeni nazw root\cimv2 przy użyciu narzędzia MOF.

#pragma namespace("\\\\.\\Root\\cimv2")

[Abstract, Provider("MyProvider") : ToSubClass]
class MyClass_BaseDisk
{
  [read : ToSubClass, key : ToSubClass ] string DeviceID;
  [read : ToSubClass] uint32 State;
  [read : ToSubClass, write : ToSubClass] uint64 LimitUsers;
};

Aby uzyskać więcej informacji, zobacz Tworzenie klasy pochodnej, aby zapoznać się z przykładem klasy dynamicznej pochodzącej z tej klasy bazowej.

Tworzenie klasy bazowej za pomocą języka C++

Tworzenie klasy bazowej przy użyciu interfejsu API usługi WMI jest głównie serią poleceń Put, które definiują klasę i rejestrują klasę w usłudze WMI. Głównym celem tego interfejsu API jest umożliwienie aplikacjom klienckim tworzenia klas bazowych. Można jednak również zlecić dostawcy użycie tego interfejsu API do utworzenia klasy bazowej. Jeśli na przykład uważasz, że kod MOF dostawcy nie zostanie poprawnie zainstalowany, możesz poinstruować dostawcę, aby automatycznie utworzył poprawne klasy w repozytorium WMI. Aby uzyskać więcej informacji na temat dostawców, zobacz Pisanie dostawcy klasowego.

Uwaga

Nie można zmienić klas w trakcie działania dostawców. Należy zatrzymać działanie, zmienić klasę, a następnie ponownie uruchomić usługę Windows Management. Wykrywanie zmiany klasy nie jest obecnie możliwe.

Kod wymaga następującego odwołania do poprawnego skompilowania.

#include <wbemidl.h>

Nową klasę bazową można utworzyć programowo przy użyciu interfejsu API com dla usługi WMI.

Aby utworzyć nową klasę bazową przy użyciu interfejsu API WMI

Pobierz definicję nowej klasy, wywołując metodę IWbemServices::GetObject za pomocą parametru strObjectPath ustawionego na wartość null.

W poniższym przykładzie kodu pokazano, jak pobrać definicję dla nowej klasy.
```
IWbemServices* pSvc = 0;
IWbemContext* pCtx = 0;
IWbemClassObject* pNewClass = 0;
IWbemCallResult* pResult = 0;
HRESULT hRes = pSvc->GetObject(0, 0, pCtx, &pNewClass, &pResult);
```
Ustanów nazwę klasy, ustawiając właściwość systemu __CLASS za pomocą wywołania metody IWbemClassObject::Put.

Poniższy przykład kodu pokazuje, jak nazwać klasę, ustawiając właściwość systemu __CLASS.
```
VARIANT v;
VariantInit(&v);
V_VT(&v) = VT_BSTR;

V_BSTR(&v) = SysAllocString(L"Example");
BSTR Class = SysAllocString(L"__CLASS");
pNewClass->Put(Class, 0, &v, 0);
SysFreeString(Class);
VariantClear(&v);
```
Utwórz właściwość klucza lub właściwości, wywołując IWbemClassObject::Put.

W poniższym przykładzie kodu pokazano, jak utworzyć właściwość indeksu, która jest oznaczona jako właściwość kluczowa w kroku 4.
```
  BSTR KeyProp = SysAllocString(L"Index");
  pNewClass->Put(KeyProp, 0, NULL, CIM_STRING);
```

Dołącz standardowy kwalifikator klucza do właściwości klucza, najpierw wywołując metodę IWbemClassObject::GetPropertyQualifierSet, a następnie metodę IWbemQualifierSet::Put.

Poniższy przykład kodu pokazuje, jak dołączyć standardowy kwalifikator do właściwości klucza.

  IWbemQualifierSet *pQual = 0;
  pNewClass->GetPropertyQualifierSet(KeyProp, &pQual);
  SysFreeString(KeyProp);

  V_VT(&v) = VT_BOOL;
  V_BOOL(&v) = VARIANT_TRUE;
  BSTR Key = SysAllocString(L"Key");

  pQual->Put(Key, &v, 0);   // Flavors not required for Key 
  SysFreeString(Key);

  // No longer need the qualifier set for "Index"
  pQual->Release();   
  VariantClear(&v);

Utwórz inne właściwości klasy za pomocą IWbemClassObject::Put.

W poniższym przykładzie kodu opisano sposób tworzenia dodatkowych właściwości.

  V_VT(&v) = VT_BSTR;
  V_BSTR(&v) = SysAllocString(L"<default>");
  BSTR OtherProp = SysAllocString(L"OtherInfo");
  pNewClass->Put(OtherProp, 0, &v, CIM_STRING);
  SysFreeString(OtherProp);
  VariantClear(&v);

  OtherProp = SysAllocString(L"IntVal");
  pNewClass->Put(OtherProp, 0, NULL, CIM_SINT32); // NULL is default
  SysFreeString(OtherProp);

Zarejestruj nową klasę, wywołując IWbemServices::PutClass.

Ponieważ nie można zdefiniować kluczy i indeksów po zarejestrowaniu nowej klasy, upewnij się, że wszystkie właściwości zostały zdefiniowane przed wywołaniem PutClass.

W poniższym przykładzie kodu opisano sposób rejestrowania nowej klasy.
```
  hRes = pSvc->PutClass(pNewClass, 0, pCtx, &pResult);
  pNewClass->Release();
```

Poniższy przykład kodu łączy przykłady kodu omówione w poprzedniej procedurze i pokazuje, jak utworzyć klasę bazową przy użyciu interfejsu API usługi WMI.

void CreateClass(IWbemServices *pSvc)
{
  IWbemClassObject *pNewClass = 0;
  IWbemContext *pCtx = 0;
  IWbemCallResult *pResult = 0;

  // Get a class definition. 
  // ============================
  HRESULT hRes = pSvc->GetObject(0, 0, pCtx, &pNewClass, &pResult);
  VARIANT v;
  VariantInit(&v);

  // Create the class name.
  // ============================
  V_VT(&v) = VT_BSTR;
  V_BSTR(&v) = SysAllocString(L"Example");
  BSTR Class = SysAllocString(L"__CLASS");
  pNewClass->Put(Class, 0, &v, 0);
  SysFreeString(Class);
  VariantClear(&v);

  // Create the key property. 
  // ============================
  BSTR KeyProp = SysAllocString(L"Index");
  pNewClass->Put(KeyProp, 0, NULL, CIM_STRING);

  // Attach Key qualifier to mark the "Index" property as the key.
  // ============================
  IWbemQualifierSet *pQual = 0;
  pNewClass->GetPropertyQualifierSet(KeyProp, &pQual);
  SysFreeString(KeyProp);

  V_VT(&v) = VT_BOOL;
  V_BOOL(&v) = VARIANT_TRUE;
  BSTR Key = SysAllocString(L"Key");

  pQual->Put(Key, &v, 0);   // Flavors not required for Key 
  SysFreeString(Key);

  // No longer need the qualifier set for "Index"
  pQual->Release();     
  VariantClear(&v);

  // Create other properties.
  // ============================
  V_VT(&v) = VT_BSTR;
  V_BSTR(&v) = SysAllocString(L"<default>");
  BSTR OtherProp = SysAllocString(L"OtherInfo");
  pNewClass->Put(OtherProp, 0, &v, CIM_STRING);
  SysFreeString(OtherProp);
  VariantClear(&v);

  OtherProp = SysAllocString(L"IntVal");
  pNewClass->Put(OtherProp, 0, NULL, CIM_SINT32); // NULL is default
  SysFreeString(OtherProp);
  
  // Register the class with WMI
  // ============================
  hRes = pSvc->PutClass(pNewClass, 0, pCtx, &pResult);
  pNewClass->Release();
}

Tworzenie klasy

Udostępnij za pośrednictwem

Tworzenie klasy bazowej usługi WMI

Tworzenie klasy bazowej przy użyciu narzędzia MOF

Tworzenie klasy bazowej za pomocą języka C++

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

Tworzenie klasy bazowej usługi WMI

Tworzenie klasy bazowej przy użyciu narzędzia MOF

Tworzenie klasy bazowej za pomocą języka C++

Tematy pokrewne

Opinia

Dodatkowe zasoby