Sdílet prostřednictvím

Vytvoření základní třídy WMI

  • Článek

Doporučený způsob, jak vytvořit novou základní třídu WMI pro zprostředkovatele WMI, je v souboru MOF (Managed Object Format). Můžete také vytvořit základní třídu pomocí rozhraní COM API pro rozhraní WMI. Přestože můžete ve skriptu vytvořit základní nebo odvozenou třídu, třída není užitečná, pokud jí a jejím podtřídám neposkytuje data zprostředkovatel.

V tomto tématu jsou popsány následující části:

Vytvoření základní třídy pomocí MOF

Třídy WMI se obvykle spoléhají na dědičnost. Před vytvořením základní třídy zkontrolujte třídy MODELU CIM (Common Information Model), které jsou k dispozici v rámci úlohy Distribuované správy (DMTF).

Pokud mnoho odvozených tříd bude používat stejné vlastnosti, vložte tyto vlastnosti a metody do základní třídy. Maximální počet vlastností, které můžete definovat ve třídě WMI, je 1024.

Při vytváření základní třídy si projděte následující seznam pokynů pro názvy tříd:

  • Používejte velká i malá písmena.

  • Zahajte název třídy písmenem.

  • Nepoužívejte úvodní ani koncové podtržítko.

  • Definujte všechny zbývající znaky jako písmena, číslice nebo podtržítka.

  • Použijte konvenci konzistentního pojmenování.

    I když to není třeba, dobrým zvykem pojmenování třídy je dvě komponenty spojit podtržítkem. Pokud je to možné, měl by název dodavatele obsahovat první polovinu názvu a popisný název třídy by měl být druhou částí.

Poznámka

Třídy nelze během provádění zprostředkovatelů změnit. Musíte zastavit aktivitu, změnit třídu a poté restartovat službu Windows Management. Zjištění změny třídy v současné době není možné.

 

V MOF vytvořte základní třídu tím, že ji pojmenujete klíčovým slovem třídy , aniž byste uvedli nadřazenou třídu.

Vytvoření základní třídy pomocí kódu MOF

  1. Použijte klíčové slovo třídy s názvem nové třídy, následovanou dvojicí složených závorek a středníkem. Přidejte mezi složené závorky vlastnosti a metody pro třídu. Následující příklad kódu je k dispozici.

    Následující příklad kódu ukazuje, jak by měla být definována základní třída.

    class MyClass_BaseDisk
{
};

    Následující příklad kódu ukazuje nesprávnou definici základní třídy.

    class MyClass_BaseDisk : CIM_LogicalDisk
{
};

  2. Přidejte všechny kvalifikátory třídy před klíčovým slovem třídy a upravte způsob použití třídy. Umístěte kvalifikátory mezi hranaté závorky. Další informace o kvalifikátorech pro úpravu tříd naleznete v tématu Kvalifikátory WMI. Pomocí kvalifikátoru Abstraktní označte, že nelze přímo vytvořit instanci této třídy. Abstraktní třídy se často používají k definování vlastností nebo metod, které budou používány několika odvozenými třídami. Další informace naleznete v tématu Vytvoření odvozené třídy.

    Následující příklad kódu definuje třídu jako abstraktní a definuje zprostředkovatele, který bude poskytovat data. Kvalifikátor ToSubClass s příchutí naznačuje, že informace v kvalifikátoru Provider jsou děděny odvozenými třídami.

    [Abstract, Provider("MyProvider") : ToSubClass]
class MyClass_BaseDisk
{
};

  3. Přidejte vlastnosti a metody třídy uvnitř hranatých závorek před název vlastnosti nebo metody. Další informace naleznete v tématu Přidání vlastnosti a Vytvoření metody. Tyto vlastnosti a metody můžete upravit pomocí kvalifikátorů MOF. Další informace naleznete v tématu Přidání kvalifikátoru.

    Následující příklad kódu ukazuje, jak upravit vlastnosti a metody pomocí kvalifikátorů MOF.

    [read : ToSubClass, key : ToSubClass ] string DeviceID;
  [read : ToSubClass] uint32 State;
  [read : ToSubclass, write : ToSubClass] uint64 LimitUsers;

  4. Uložte soubor MOF s příponou .mof.

  5. Zaregistrujte třídu ve službě WMI spuštěním Mofcomp.exe v souboru.

    mofcomp.exenewmof.mof

    Pokud nepoužíváte přepínač -N nebo příkaz preprocesoru #pragma pro definování oboru názvů, zkompilované třídy MOF budou uloženy v kořenovém či výchozím oboru názvů v úložišti. Další informace naleznete v tématu mofcomp.

Následující příklad kódu kombinuje příklady kódu MOF probírané v předchozím postupu a ukazuje, jak vytvořit základní třídu v oboru názvů root\cimv2 pomocí 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;
};

Další informace naleznete v tématu Vytvoření odvozené třídy příklad dynamické třídy odvozené z této základní třídy.

Vytvoření základní třídy pomocí jazyka C++

Vytvoření základní třídy pomocí rozhraní WMI API je hlavně řada příkazů Put, které definují třídu a registrují třídu ve službě WMI. Hlavním účelem tohoto rozhraní API je umožnit klientským aplikacím vytvářet základní třídy. Můžete také požádat poskytovatele, aby pomocí tohoto rozhraní API vytvořil základní třídu. Pokud se například domníváte, že kód MOF pro vašeho poskytovatele nebude správně nainstalován, můžete poskytovateli dát pokyn, aby v úložišti WMI automaticky vytvořil správné třídy. Další informace o poskytovatelích naleznete v části Zápis poskytovatele třídy.

Poznámka

Třídy nelze měnit v průběhu provádění zprostředkovatelů. Musíte zastavit aktivitu, změnit třídu a poté restartovat službu Windows Management. Zjištění změny třídy v současné době není možné.

 

Kód vyžaduje následující odkaz, aby se správně zkompiloval.

#include <wbemidl.h>

Novou základní třídu můžete vytvořit programově pomocí rozhraní COM API pro rozhraní WMI.

Vytvoření nové základní třídy pomocí rozhraní WMI API

  1. Načtěte definici nové třídy voláním metody IWbemServices::GetObject s parametrem strObjectPath nastaveným na hodnotu null.

    Následující příklad kódu ukazuje, jak načíst definici pro novou třídu.

    IWbemServices* pSvc = 0;
IWbemContext* pCtx = 0;
IWbemClassObject* pNewClass = 0;
IWbemCallResult* pResult = 0;
HRESULT hRes = pSvc->GetObject(0, 0, pCtx, &pNewClass, &pResult);

  2. Vytvořte název třídy nastavením vlastnosti systému __CLASS voláním metody IWbemClassObject::P ut.

    Následující příklad kódu ukazuje, jak pojmenovat třídu nastavením __CLASS systémové vlastnosti.

    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);

  3. Vytvořte klíčové vlastnosti nebo vlastnosti voláním IWbemClassObject::Put.

    Následující příklad kódu popisuje, jak vytvořit Index vlastnost, která je označena jako klíč vlastnost v kroku 4.

      BSTR KeyProp = SysAllocString(L"Index");
  pNewClass->Put(KeyProp, 0, NULL, CIM_STRING);

  4. Připojte standardní kvalifikátor Key k klíčové vlastnosti tak, že nejprve zavoláte metodu IWbemClassObject::GetPropertyQualifierSet a pak metodu IWbemQualifierSet::Put.

    Následující příklad kódu ukazuje, jak připojit Key standardní kvalifikátor k vlastnost 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);

  5. Vytvořte další vlastnosti třídy pomocí IWbemClassObject::Put.

    Následující příklad kódu popisuje, jak vytvořit další vlastnosti.

      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);

  6. Zaregistrujte novou třídu voláním IWbemServices::PutClass.

    Protože po registraci nové třídy nelze definovat klíče a indexy, před voláním PutClassse ujistěte, že jste definovali všechny vlastnosti.

    Následující příklad kódu popisuje, jak zaregistrovat novou třídu.

      hRes = pSvc->PutClass(pNewClass, 0, pCtx, &pResult);
  pNewClass->Release();

Následující příklad kódu kombinuje příklady kódu probírané v předchozím postupu a ukazuje, jak vytvořit základní třídu pomocí rozhraní WMI API.

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();
}

Vytvoření třídy