Delen via

Een WMI-basisklasse maken

  • Artikel

De aanbevolen manier om een nieuwe WMI-basisklasse voor een WMI-provider te maken, bevindt zich in een MOF-bestand (Managed Object Format). U kunt ook een basisklasse maken met behulp van de COM-API voor WMI-. Hoewel u een basis- of afgeleide klasse in een script kunt maken, zonder dat een provider gegevens aan de klasse en de bijbehorende subklassen levert, is de klasse niet nuttig.

In dit onderwerp worden de volgende secties besproken:

Een basisklasse maken met MOF

WMI-klassen zijn meestal afhankelijk van overerving. Voordat u een basisklasse maakt, controleert u de CIM-klassen (Common Information Model) die beschikbaar zijn via de Distributed Management Task Force (DMTF-).

Als veel afgeleide klassen dezelfde eigenschappen gebruiken, plaatst u deze eigenschappen en methoden in uw basisklasse. Het maximum aantal eigenschappen dat u kunt definiëren in een WMI-klasse is 1024.

Bekijk bij het maken van een basisklasse de volgende lijst met richtlijnen voor klassenamen:

  • Gebruik zowel hoofdletters als kleine letters.

  • Begin een klassenaam met een letter.

  • Gebruik geen underscore aan het begin of einde.

  • Definieer alle resterende tekens als letters, cijfers of onderstrepingstekens.

  • Gebruik een consistente naamconventie.

    Hoewel dit niet nodig is, is een goede naamconventie voor een klasse twee onderdelen die door een onderstrepingsteken worden samengevoegd. Indien mogelijk moet de naam van een leverancier de eerste helft van de naam vormen en moet een beschrijvende klassenaam het tweede deel zijn.

Notitie

Klassen kunnen niet worden gewijzigd tijdens het uitvoeren van providers. U moet de activiteit stoppen, de klasse wijzigen en vervolgens de Windows Management-service opnieuw starten. Het detecteren van een klassewijziging is momenteel niet mogelijk.

 

Maak in MOF een basisklasse door deze een naam te geven met de klasse trefwoord, maar niet om een bovenliggende klasse aan te geven.

Een basisklasse maken met behulp van MOF-code

  1. Gebruik de -klasse trefwoord met de naam van de nieuwe klasse, gevolgd door een paar accolades en een puntkomma. Voeg eigenschappen en methoden toe aan de klasse tussen de accolades. Het volgende codevoorbeeld is opgegeven.

    In het volgende codevoorbeeld ziet u hoe een basisklasse moet worden gedefinieerd.

    class MyClass_BaseDisk
{
};

    In het volgende codevoorbeeld ziet u een onjuiste definitie van een basisklasse.

    class MyClass_BaseDisk : CIM_LogicalDisk
{
};

  2. Voeg klassenkwalificaties toe vóór het class-trefwoord om de manier waarop de klasse wordt gebruikt te veranderen. Plaats de kwalificaties tussen vierkante haken. Zie WMI Kwalificatiesvoor meer informatie over kwalificaties voor het wijzigen van klassen. Gebruik de abstracte kwalificatie om aan te geven dat u geen exemplaar van deze klasse rechtstreeks kunt maken. Abstracte klassen worden vaak gebruikt om eigenschappen of methoden te definiëren die door verschillende afgeleide klassen worden gebruikt. Zie Een afgeleide klasse makenvoor meer informatie.

    In het volgende codevoorbeeld wordt de klasse gedefinieerd als abstract en wordt de provider gedefinieerd die de gegevens levert. De ToSubClass aanduiding variant geeft aan dat de informatie in de Provider aanduiding wordt overgenomen door afgeleide klassen.

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

  3. Voeg de eigenschappen en methoden voor de klasse toe binnen vierkante haken vóór de eigenschap of methodenaam. Zie Een eigenschap toevoegen en Een methode makenvoor meer informatie. U kunt deze eigenschappen en methoden wijzigen met behulp van MOF-kwalificaties. Zie Een kwalificatie toevoegenvoor meer informatie.

    In het volgende codevoorbeeld ziet u hoe u eigenschappen en methoden wijzigt met MOF-kwalificaties.

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

  4. Sla het MOF-bestand op met de extensie .mof.

  5. Registreer de klasse bij WMI door Mofcomp.exe uit te voeren op het bestand.

    mofcomp.exenewmof.mof

    Als u de -N-switch of de preprocessoropdracht #pragma-naamruimte niet gebruikt om een naamruimte op te geven, worden de gecompileerde MOF-klassen opgeslagen in de root\default naamruimte in de opslagplaats. Voor meer informatie, zie mofcomp.

In het volgende codevoorbeeld worden de MOF-codevoorbeelden gecombineerd die in de vorige procedure zijn besproken en ziet u hoe u een basisklasse maakt in de root\cimv2-naamruimte met behulp van 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;
};

Zie Een afgeleide klasse maken voor een voorbeeld van een dynamische klasse die is afgeleid van deze basisklasse voor meer informatie.

Een basisklasse maken met C++

Het maken van een basisklasse met behulp van de WMI-API is voornamelijk een reeks Put-opdrachten die de klasse definiëren en de klasse registreren bij WMI. Het belangrijkste doel van deze API is om clienttoepassingen in staat te stellen basisklassen te maken. U kunt echter ook een provider deze API laten gebruiken om een basisklasse te maken. Als u bijvoorbeeld denkt dat de MOF-code voor uw provider niet correct wordt geïnstalleerd, kunt u uw provider instrueren om automatisch de juiste klassen te maken in de WMI-opslagplaats. Voor meer informatie over providers, zie Een klasseprovider schrijven.

Notitie

Klassen kunnen niet worden gewijzigd tijdens het uitvoeren van providers. U moet de activiteit stoppen, de klasse wijzigen en vervolgens de Windows Management-service opnieuw starten. Het detecteren van een klassewijziging is momenteel niet mogelijk.

 

Voor de code is de volgende verwijzing vereist om correct te compileren.

#include <wbemidl.h>

U kunt programmatisch een nieuwe basisklasse maken met behulp van de COM-API voor WMI-.

Een nieuwe basisklasse maken met de WMI-API

  1. Haal een definitie voor de nieuwe klasse op door de methode IWbemServices::GetObject aan te roepen met de parameter strObjectPath ingesteld op een null--waarde.

    In het volgende codevoorbeeld ziet u hoe u een definitie voor een nieuwe klasse ophaalt.

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

  2. Stel een naam voor de klasse in door de __CLASS systeemeigenschap in te stellen met een oproep van de methode IWbemClassObject::Put.

    In het volgende codevoorbeeld ziet u hoe u de klasse een naam geeft door de __CLASS systeemeigenschap in te stellen.

    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. Maak de sleuteleigenschap of eigenschappen door IWbemClassObject::Putaan te roepen.

    In het volgende codevoorbeeld wordt beschreven hoe u de eigenschap Index maakt, die wordt gelabeld als een sleuteleigenschap in stap 4.

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

  4. Koppel de Key standaardkwalificatie aan de sleuteleigenschap door eerst de IWbemClassObject::GetPropertyQualifierSet methode aan te roepen en vervolgens de methode IWbemQualifierSet::Put.

    In het volgende codevoorbeeld ziet u hoe u de Key standaardkwalificatie koppelt aan de sleuteleigenschap.

      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. Maak andere eigenschappen van de klasse met IWbemClassObject::Put.

    In het volgende codevoorbeeld wordt beschreven hoe u aanvullende eigenschappen maakt.

      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. Registreer de nieuwe klasse door IWbemServices::P utClassaan te roepen.

    Omdat u geen sleutels en indexen kunt definiëren nadat u een nieuwe klasse hebt geregistreerd, moet u ervoor zorgen dat u al uw eigenschappen hebt gedefinieerd voordat u PutClass-aanroept.

    In het volgende codevoorbeeld wordt beschreven hoe u een nieuwe klasse registreert.

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

Het volgende codevoorbeeld combineert de codevoorbeelden die in de vorige procedure zijn besproken en laat zien hoe u een basisklasse maakt met behulp van de 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();
}

Een klasse- maken