Een WMI-afgeleide klasse maken

Het maken van een afgeleide klasse in WMI is vergelijkbaar met het maken van een basisklasse. Net als bij een basisklasse moet u eerst de afgeleide klasse definiëren en vervolgens de afgeleide klasse registreren bij WMI. Het belangrijkste verschil is dat u eerst de bovenliggende klasse moet vinden waaruit u wilt afleiden. Voor meer informatie, zie Een klasseprovider schrijven en Een instanceprovider schrijven.

De aanbevolen manier om klassen voor een provider te maken, is in MOF-bestanden (Managed Object Format). Verschillende afgeleide klassen die aan elkaar zijn gerelateerd, moeten worden gegroepeerd in een MOF-bestand, samen met eventuele basisklassen waaruit ze eigenschappen of methoden afleiden. Als u elke klasse in een afzonderlijk MOF-bestand plaatst, moet elk bestand worden gecompileerd voordat de provider goed kan werken.

Nadat u uw klas hebt gemaakt, moet u alle exemplaren van uw klas verwijderen voordat u een van de volgende activiteiten op uw afgeleide klasse kunt uitvoeren:

• Wijzig de basisklasse van uw afgeleide klasse.
• Eigenschappen toevoegen of verwijderen.
• Eigenschappentypen aanpassen.
• Voeg Key of geïndexeerde kwalificaties toe of verwijder ze.
• Singleton, Dynamicof Abstract kwalificatie toevoegen of verwijderen.

Wanneer u uw afgeleide klasse declareert, moet u rekening houden met de volgende regels en beperkingen:

• De bovenliggende klasse van de afgeleide klasse moet al bestaan.

  De declaratie van de bovenliggende klasse kan worden weergegeven in hetzelfde MOF-bestand als de afgeleide klasse of in een ander bestand. Als de bovenliggende klasse onbekend is, genereert de compiler een runtimefout.

• Een afgeleide klasse kan slechts één bovenliggende klasse hebben.

  WMI biedt geen ondersteuning voor meerdere overnames. Een bovenliggende klasse kan echter veel afgeleide klassen hebben.

• U kunt indexen definiëren voor afgeleide klassen, maar WMI gebruikt deze indexen niet.

  Als u daarom een index opgeeft voor een afgeleide klasse, worden de prestaties van query's voor exemplaren van de afgeleide klasse niet verbeterd. U kunt de prestaties van een query op een afgeleide klasse verbeteren door geïndexeerde eigenschappen op te geven voor de bovenliggende klasse van de afgeleide klasse.

• Afgeleide klassedefinities kunnen complexer zijn en kunnen functies bevatten als aliassen, kwalificaties en kwalificatiearoma's.

  Zie Een alias maken en Een kwalificatie toevoegenvoor meer informatie.

• Als u een kwalificatie wilt wijzigen, de standaardwaarde van een basisklasse-eigenschap wilt wijzigen of een verwijzings- of ingesloten objecteigenschap van een basisklasse sterk wilt typen, moet u de hele basisklasse opnieuw declareren.

• Het maximum aantal eigenschappen dat u kunt definiëren in een WMI-klasse is 1024.

Net als bij de basisklasse is het meest voorkomende gebruik van deze techniek door clienttoepassingen. Een provider kan echter ook een afgeleide klasse maken. Zie Een basisklasse maken en een klasseprovider schrijvenvoor meer informatie.

Voor het codevoorbeeld in dit onderwerp is de volgende #include instructie vereist om correct te compileren.

#include <wbemidl.h>

In de volgende procedure wordt beschreven hoe u een afgeleide klasse maakt met behulp van C++.

Een afgeleide klasse maken met behulp van C++

1. Zoek de basisklasse met een aanroep naar IWbemServices::GetObject.

   In het volgende codevoorbeeld ziet u hoe u de basisklasse Voorbeeld kunt vinden.

   // The pSv variable is of type IWbemServices *
   
   IWbemClassObject *pNewDerivedClass = 0;
   IWbemClassObject *pExampleClass = 0;
   IWbemContext *pCtx = 0;
   IWbemCallResult *pResult = 0;
   
   BSTR PathToClass = SysAllocString(L"Example");
   HRESULT hRes = pSvc->GetObject(PathToClass, 0, pCtx, &pExampleClass, &pResult);
   SysFreeString(PathToClass);
   

2. Maak een afgeleid object van de basisklasse met een aanroep naar IWbemClassObject::SpawnDerivedClass.

   In het volgende codevoorbeeld ziet u hoe u een afgeleid klasseobject maakt.

   pExampleClass->SpawnDerivedClass(0, &pNewDerivedClass);
   pExampleClass->Release();  // Don't need the parent class any more
   

3. Stel een naam voor de klasse in door de __CLASS systeemeigenschap in te stellen met een aanroep naar de methode IWbemClassObject::Put.

   In het volgende codevoorbeeld ziet u hoe u een naam toewijst aan de afgeleide klasse.

   VARIANT v;
   VariantInit(&v);
   
   V_VT(&v) = VT_BSTR;
   V_BSTR(&v) = SysAllocString(L"Example2");
   BSTR Class = SysAllocString(L"__CLASS");
   pNewDerivedClass->Put(Class, 0, &v, 0);
   SysFreeString(Class);
   VariantClear(&v);
   

4. Maak extra eigenschappen met IWbemClassObject::Put.

   In het volgende codevoorbeeld ziet u hoe u aanvullende eigenschappen maakt.

   BSTR OtherProp = SysAllocString(L"OtherInfo2");
   pNewDerivedClass->Put(OtherProp, 0, NULL, CIM_STRING); 
   SysFreeString(OtherProp);
   

5. Sla de nieuwe klasse op door IWbemServices::PutClassaan te roepen.

   In het volgende codevoorbeeld ziet u hoe u de nieuwe afgeleide klasse opslaat.

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

In het volgende codevoorbeeld worden de codevoorbeelden gecombineerd die in de vorige procedure zijn besproken om te beschrijven hoe u een afgeleide klasse maakt met behulp van de WMI-API.

void CreateDerivedClass(IWbemServices *pSvc)
{
  IWbemClassObject *pNewDerivedClass = 0;
  IWbemClassObject *pExampleClass = 0;
  IWbemContext *pCtx = 0;
  IWbemCallResult *pResult = 0;

  BSTR PathToClass = SysAllocString(L"Example");
  HRESULT hRes = pSvc->GetObject(PathToClass, 0, pCtx, 
    &pExampleClass, &pResult);
  SysFreeString(PathToClass);

  if (hRes != 0)
    return;

  pExampleClass->SpawnDerivedClass(0, &pNewDerivedClass);
  pExampleClass->Release();  // The parent class is no longer needed

  VARIANT v;
  VariantInit(&v);

  // Create the class name.
  // =====================

  V_VT(&v) = VT_BSTR;
  V_BSTR(&v) = SysAllocString(L"Example2");
  BSTR Class = SysAllocString(L"__CLASS");
  pNewDerivedClass->Put(Class, 0, &v, 0);
  SysFreeString(Class);
  VariantClear(&v);

  // Create another property.
  // =======================
  BSTR OtherProp = SysAllocString(L"OtherInfo2");
  // No default value
  pNewDerivedClass->Put(OtherProp, 0, NULL, CIM_STRING); 
  SysFreeString(OtherProp);
  
  // Register the class with WMI. 
  // ============================
  hRes = pSvc->PutClass(pNewDerivedClass, 0, pCtx, &pResult);
  pNewDerivedClass->Release();
}

In de volgende procedure wordt beschreven hoe u een afgeleide klasse definieert met behulp van MOF-code.

Een afgeleide klasse definiëren met behulp van MOF-code

1. Definieer uw afgeleide klasse met het trefwoord Klasse, gevolgd door de naam van uw afgeleide klasse en de naam van de bovenliggende klasse, gescheiden door een dubbele punt.

   In het volgende codevoorbeeld wordt een implementatie van een afgeleide klasse beschreven.

   class MyClass 
   {
       [key] string   strProp;
       sint32   dwProp1;
       uint32       dwProp2;
   };
   
   class MyDerivedClass : MyClass
   {
       string   strDerivedProp;
       sint32   dwDerivedProp;
   };
   

2. Compileer uw MOF-code als u klaar bent met de MOF-compiler.

   Zie MOF-bestanden compilerenvoor meer informatie.

Verwante onderwerpen

Een klasse maken