Freigeben über

Erstellen einer abgeleiteten Klasse in WMI

  • Artikel

Das Erstellen einer abgeleiteten Klasse in WMI erfolgt ähnlich wie das Erstellen einer Basisklasse. Wie bei einer Basisklasse müssen Sie zunächst die abgeleitete Klasse definieren und dann die abgeleitete Klasse bei WMI registrieren. Der Hauptunterschied besteht darin, dass Sie zuerst die übergeordnete Klasse suchen müssen, von der Sie die Klasse ableiten möchten. Weitere Informationen finden Sie unter Schreiben eines Klassenanbieters und Schreiben eines Instanzanbieters.

Die empfohlene Methode zum Erstellen von Klassen für einen Anbieter ist die Erstellung in MOF-Dateien (Managed Object Format). Mehrere abgeleitete, verwandte Klassen sollten zusammen mit allen Basisklassen, von denen Eigenschaften oder Methoden abgeleitet werden, in einer MOF-Datei gruppiert werden. Wenn Sie die einzelnen Klassen in einer separaten MOF-Datei platzieren, muss jede Datei kompiliert werden, damit der Anbieter ordnungsgemäß funktionieren kann.

Nachdem Sie die Klasse erstellt haben, müssen Sie alle Instanzen der Klasse löschen, damit Sie eine der folgenden Aktivitäten für die abgeleitete Klasse ausführen können:

  • Ändern der übergeordneten Klasse der abgeleiteten Klasse.
  • Hinzufügen oder Entfernen von Eigenschaften.
  • Ändern Sie Eigenschaftstypen .
  • Fügen Sie die Qualifizierer Keyoder Indexed hinzu oder entfernen Sie sie.
  • Hinzufügen oder Entfernen der Qualifizierer Singleton, Dynamic oder Abstract.

Hinweis

Um eine Eigenschaft oder einen Qualifizierer hinzuzufügen, zu entfernen oder zu ändern, rufen Sie IWbemServices::PutClass oder SWbemObject.Put_ auf, und legen Sie den flag-Parameter auf „force mode“ fest. Der Abstract-Qualifizierer kann nur verwendet werden, wenn die übergeordnete Klasse abstrakt ist.

 

Beachten Sie beim Deklarieren einer abgeleiteten Klasse die folgenden Regeln und Einschränkungen:

  • Die übergeordnete Klasse der abgeleiteten Klasse muss bereits vorhanden sein.

    Die Deklaration der übergeordneten Klasse kann in derselben MOF-Datei wie die abgeleitete Klasse oder in einer anderen Datei erfolgen. Wenn die übergeordnete Klasse unbekannt ist, generiert der Compiler einen Laufzeitfehler.

  • Eine abgeleitete Klasse kann nur über eine einzelne übergeordnete Klasse verfügen.

    WMI unterstützt keine Mehrfachvererbung. Eine übergeordnete Klasse kann jedoch über mehrere abgeleitete Klassen verfügen.

  • Sie können Indizes für abgeleitete Klassen definieren. Diese Indizes werden aber von WMI nicht verwendet.

    Daher verbessert das Angeben eines Index für eine abgeleitete Klasse nicht die Leistung von Abfragen für Instanzen der abgeleiteten Klasse. Sie können die Leistung einer Abfrage für eine abgeleitete Klasse verbessern, indem Sie indizierte Eigenschaften für die übergeordnete Klasse der abgeleiteten Klasse angeben.

  • Abgeleitete Klassendefinitionen können komplexer sein und Features wie Aliase, Qualifizierer und Qualifizierervarianten enthalten.

    Weitere Informationen finden Sie unter Erstellen eines WMI-Alias und Hinzufügen eines Qualifizierers.

  • Wenn Sie einen Qualifizierer ändern, den Standardwert einer Basisklasseneigenschaft ändern oder eine Eigenschaft eines Referenz- oder eingebetteten Objekts einer Basisklasse stärker typisieren möchten, müssen Sie die gesamte Basisklasse erneut deklarieren.

  • Die maximale Anzahl von Eigenschaften, die Sie in einer WMI-Klasse definieren können, ist 1024.

Hinweis

Klassen können während der Ausführung von Anbietern nicht geändert werden. Sie müssen die Aktivität beenden, die Klasse ändern und dann den Windows-Verwaltungsdienst neu starten. Das Erkennen einer Klassenänderung ist derzeit nicht möglich.

 

Wie bei der Basisklasse wird dieses Verfahren am häufigsten von Clientanwendungen verwendet. Ein Anbieter kann jedoch auch eine abgeleitete Klasse erstellen. Weitere Informationen finden Sie unter Erstellen einer WMI-Basisklasse und Schreiben eines Klassenanbieters.

Für das Codebeispiel in diesem Thema ist die folgende #include-Anweisung erforderlich, damit der Code korrekt kompiliert wird.

#include <wbemidl.h>

Im folgenden Verfahren wird beschrieben, wie eine abgeleitete Klasse mit C++ erstellt wird.

So erstellen Sie eine abgeleitete Klasse mit C++

  1. Suchen Sie die Basisklasse mit einem Aufruf von IWbemServices::GetObject.

    Im folgenden Codebeispiel wird die Verwendung der Example-Basisklasse veranschaulicht.

    // 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. Erstellen Sie mit einem Aufruf von IWbemClassObject::SpawnDerivedClass ein abgeleitetes Objekt aus der Basisklasse.

    Das folgende Codebeispiel veranschaulicht, wie ein abgeleitetes Klassenobjekt erstellt wird.

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

  3. Richten Sie einen Namen für die Klasse ein, indem Sie die __CLASS-Systemeigenschaft mit einem Aufruf der IWbemClassObject::Put-Methode festlegen.

    Das folgende Codebeispiel veranschaulicht, wie der abgeleiteten Klasse ein Name zugewiesen wird.

    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. Erstellen Sie mit IWbemClassObject::Put weitere Eigenschaften.

    Das folgende Codebeispiel veranschaulicht, wie weitere Eigenschaften erstellt werden.

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

  5. Speichern Sie die neue Klasse durch Aufrufen von IWbemServices::PutClass.

    Das folgende Codebeispiel veranschaulicht, wie die neue abgeleitete Klasse gespeichert wird.

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

Im folgenden Codebeispiel werden die im vorherigen Verfahren erläuterten Codebeispiele kombiniert, um zu veranschaulichen, wie Sie mit der WMI-API eine abgeleitete Klasse erstellt wird.

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

Im folgenden Verfahren wird beschrieben, wie eine abgeleitete Klasse mit MOF-Code definiert wird.

So definieren Sie eine abgeleitete Klasse mit MOF-Code

  1. Definieren Sie die abgeleitete Klasse mit dem Class-Schlüsselwort, gefolgt vom Namen der abgeleiteten Klasse, einem Doppelpunkt als Trennzeichen und dem Namen der übergeordneten Klasse.

    Das folgende Codebeispiel veranschaulicht die Implementierung einer abgeleiteten Klasse.

    class MyClass 
{
    [key] string   strProp;
    sint32   dwProp1;
    uint32       dwProp2;
};

class MyDerivedClass : MyClass
{
    string   strDerivedProp;
    sint32   dwDerivedProp;
};

  2. Kompilieren Sie den MOF-Code danach mit dem MOF-Compiler.

    Weitere Informationen finden Sie unter Kompilieren von MOF-Dateien.

Erstellen einer Klasse