Dela via

Skapa en WMI-basklass

  • Artikel

Det rekommenderade sättet att skapa en ny WMI-basklass för en WMI-provider är i en MOF-fil (Managed Object Format). Du kan också skapa en basklass med hjälp av com-API:et för WMI. Även om du kan skapa en bas- eller härledd klass i skriptet, utan att en provider tillhandahåller data till klassen och dess underklasser, är klassen inte användbar.

Följande avsnitt beskrivs i det här avsnittet:

Skapa en basklass med MOF

WMI-klasser förlitar sig vanligtvis på arv. Innan du skapar en basklass kontrollerar du de CIM-klasser (Common Information Model) som är tillgängliga från arbetsgruppen för distribuerad hantering (DMTF-).

Om många härledda klasser använder samma egenskaper placerar du dessa egenskaper och metoder i basklassen. Det maximala antalet egenskaper som du kan definiera i en WMI-klass är 1024.

När du skapar en basklass bör du se följande lista med riktlinjer för klassnamn:

  • Använd både versaler och gemener.

  • Börja ett klassnamn med en bokstav.

  • Använd inte ett inledande eller avslutande understreck.

  • Definiera alla återstående tecken som bokstäver, siffror eller understreck.

  • Använd en konsekvent namngivningskonvention.

    Även om det inte är nödvändigt är en bra namngivningskonvention för en klass två komponenter som är kopplade till ett understreck. När det är möjligt bör ett leverantörsnamn utgöra den första halvan av namnet och ett beskrivande klassnamn ska vara den andra delen.

Not

Det går inte att ändra klasser under körningen av leverantörer. Du måste stoppa aktiviteten, ändra klassen och sedan starta om Windows Management-tjänsten. Det går för närvarande inte att identifiera en klassändring.

 

I MOF skapar du en basklass genom att namnge den med nyckelordet -klassen, men anger inte en överordnad klass.

Skapa en basklass med hjälp av MOF-kod

  1. Använd nyckelordet -klassen med namnet på den nya klassen, följt av ett par klammerparenteser och ett semikolon. Lägg till egenskaper och metoder för klassen mellan klammerparenteserna. Följande kodexempel anges.

    I följande kodexempel visas hur en basklass ska definieras.

    class MyClass_BaseDisk
{
};

    I följande kodexempel visas en felaktig definition av en basklass.

    class MyClass_BaseDisk : CIM_LogicalDisk
{
};

  2. Lägg till en klass kvalificerare före nyckelordet för klassen för att ändra hur klassen används. Placera kvalificerarna mellan hakparenteser. Mer information om kvalifikationer för att modifiera klasser finns i WMI-kvalificerare. Använd Abstract-kvalificeraren för att ange att du inte kan skapa en instans av den här klassen direkt. Abstrakta klasser används ofta för att definiera egenskaper eller metoder som ska användas av flera härledda klasser. Mer information finns i Skapa en härledd klass.

    I följande kodexempel definieras klassen som abstrakt och den provider som ska tillhandahålla data. ToSubClass-kvalificerare anger att informationen i Provider-kvalificeraren ärvs av härledda klasser.

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

  3. Lägg till egenskaperna och metoderna för klassen inom hakparenteser före egenskapen eller metodnamnet. Mer information finns i Lägga till en egenskap och Skapa en metod. Du kan ändra dessa egenskaper och metoder med hjälp av MOF-kvalificerare. Mer information finns i Lägga till en kvalificerare.

    Följande kodexempel visar hur du ändrar egenskaper och metoder med MOF-kvalificerare.

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

  4. Spara MOF-filen med tillägget .mof.

  5. Registrera klassen med WMI genom att köra Mofcomp.exe på filen.

    mofcomp.exenewmof.mof

    Om du inte använder växeln -N eller kommandot preprocessor #pragma-namnrymd för att ange ett namnområde, lagras de kompilerade MOF-klasserna i namnområdet root\default på lagringsplatsen. Mer information finns i mofcomp.

I följande kodexempel kombineras de MOF-kodexempel som beskrevs i föregående procedur och visar hur du skapar en basklass i namnområdet root\cimv2 med hjälp av 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;
};

Mer information finns i Skapa en härledd klass för ett exempel på en dynamisk klass som härleds från den här basklassen.

Skapa en basklass med C++

Att skapa en basklass med hjälp av WMI-API:et är främst en serie Put-kommandon som definierar klassen och registrerar klassen med WMI. Huvudsyftet med det här API:et är att göra det möjligt för klientprogram att skapa basklasser. Du kan dock också låta en provider använda det här API:et för att skapa en basklass. Om du till exempel tror att MOF-koden för din provider inte kommer att installeras korrekt kan du instruera leverantören att automatiskt skapa rätt klasser i WMI-lagringsplatsen. Mer information om leverantörer finns i Att skriva en klassleverantör.

Not

Det går inte att ändra klasser medan providerstjänster körs. Du måste stoppa aktiviteten, ändra klassen och sedan starta om Windows Management-tjänsten. Det går för närvarande inte att identifiera en klassändring.

 

Koden kräver följande referens för att kompilera korrekt.

#include <wbemidl.h>

Du kan skapa en ny basklass programmatiskt med hjälp av com-API:et för WMI.

Skapa en ny basklass med WMI API-

  1. Hämta en definition för den nya klassen genom att anropa metoden IWbemServices::GetObject med parametern strObjectPath inställd på ett null- värde.

    I följande kodexempel visas hur du hämtar en definition för en ny klass.

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

  2. Upprätta ett namn för klassen genom att ange __CLASS-systemegenskapen med ett anrop till metoden IWbemClassObject::Put.

    I följande kodexempel visas hur du namnger klassen genom att ange __CLASS systemegenskap.

    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. Skapa nyckelegenskapen eller egenskaperna genom att anropa IWbemClassObject::Put.

    I följande kodexempel beskrivs hur du skapar egenskapen Index, som är märkt som en nyckelegenskap i steg 4.

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

  4. Koppla Key standardkvalificerare till nyckelegenskapen genom att först anropa metoden IWbemClassObject::GetPropertyQualifierSet och sedan metoden IWbemQualifierSet::Put.

    I följande kodexempel visas hur du kopplar standardkvalificeraren Key på nyckelegenskapen.

      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. Skapa andra egenskaper för klassen med IWbemClassObject::Put.

    I följande kodexempel beskrivs hur du skapar ytterligare egenskaper.

      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. Registrera den nya klassen genom att anropa IWbemServices::PutClass.

    Eftersom du inte kan definiera nycklar och index när du har registrerat en ny klass kontrollerar du att du har definierat alla dina egenskaper innan du anropar PutClass-.

    I följande kodexempel beskrivs hur du registrerar en ny klass.

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

I följande kodexempel kombineras de kodexempel som beskrevs i föregående procedur och visar hur du skapar en basklass med hjälp av WMI-API:et.

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

Skapa en klass