Erstellen einer WMI-Basisklasse

Artikel
07/23/2024

Die empfohlene Methode zum Erstellen einer neuen WMI-Basisklasse für einen WMI-Anbieter ist die Verwendung einer MOF-Datei (Managed Object Format). Sie können eine Basisklasse auch mit der COM-API für WMI erstellen. Sie können zwar eine Basisklasse oder abgeleitete Klasse in einem Skript erstellen, ohne dass ein Anbieter Daten für die Klasse und die zugehörigen Unterklassen angibt, die Klasse ist jedoch nicht hilfreich.

In diesem Themenbereich werden die folgenden Abschnitte behandelt:

Erstellen einer Basisklasse mithilfe von MOF
Erstellen einer Basisklasse mit C++
Verwandte Themen

Erstellen einer Basisklasse mithilfe von MOF

WMI-Klassen beruhen in der Regel auf Vererbung. Überprüfen Sie vor dem Erstellen einer Basisklasse die in Distributed Management Task Force (DMTF) verfügbaren CIM-Klassen (Common Information Model).

Wenn viele abgeleitete Klassen dieselben Eigenschaften verwenden, platzieren Sie diese Eigenschaften und Methoden in Ihrer Basisklasse. Die maximale Anzahl von Eigenschaften, die Sie in einer WMI-Klasse definieren können, ist 1024.

Beachten Sie beim Erstellen einer Basisklasse die folgende Liste der Richtlinien für Klassennamen:

Sie müssen sowohl Groß- als auch Kleinbuchstaben enthalten.
Klassennamen müssen mit einem Buchstaben beginnen.
Sie dürfen nicht mit einem Unterstrich beginnen oder enden.
Definieren Sie alle verbleibenden Zeichen als Buchstaben, Ziffern oder Unterstriche.
Verwenden Sie eine konsistente Benennungskonvention.

Eine zwar nicht erforderliche aber gute Benennungskonvention für eine Klasse sind zwei Komponenten, die durch einen Unterstrich verbunden sind. Wenn möglich, sollte ein Anbietername die erste Hälfte des Namens bilden, und ein beschreibender Klassenname sollte der zweite Teil sein.

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.

Erstellen Sie in MOF eine Basisklasse, indem Sie sie mit dem Schlüsselwort der Klasse benennen, aber keine übergeordnete Klasse angeben.

Erstellen einer Basisklasse mit MOF-Code

Verwenden Sie das Klassenschlüsselwort mit dem Namen der neuen Klasse, gefolgt von einem Paar geschweifter Klammern und einem Semikolon. Fügen Sie Eigenschaften und Methoden für die Klasse zwischen den geschweiften Klammern hinzu. Der folgende Code ist ein Beispiel.

Im folgenden Codebeispiel wird gezeigt, wie eine Basisklasse definiert werden sollte.
```
class MyClass_BaseDisk
{
};
```
Das folgende Codebeispiel zeigt eine falsche Definition einer Basisklasse.
```
class MyClass_BaseDisk : CIM_LogicalDisk
{
};
```
Fügen Sie alle Klassenqualifizierer vor dem Klassenschlüsselwort hinzu, um die Verwendung der Klasse zu ändern. Platzieren Sie die Qualifizierer zwischen eckigen Klammern. Weitere Informationen zu Qualifizierern zum Ändern von Klassen finden Sie unter WMI-Qualifizierer. Verwenden Sie den Qualifizierer Abstrakt, um anzugeben, dass keine Instanz dieser Klasse direkt erstellt werden kann. Abstrakte Klassen werden häufig verwendet, um Eigenschaften oder Methoden zu definieren, die von mehreren abgeleiteten Klassen verwendet werden. Weitere Informationen finden Sie unter Erstellen einer abgeleiteten Klasse.

Im folgenden Codebeispiel werden die Klasse als abstrakt definiert und der Anbieter definiert, der die Daten liefert. Die Variante des ToSubClass-Qualifizierers gibt an, dass die Informationen im Anbieterqualifizierer von abgeleiteten Klassen geerbt werden.
```
[Abstract, Provider("MyProvider") : ToSubClass]
class MyClass_BaseDisk
{
};
```
Fügen Sie die Eigenschaften und Methoden für die Klasse in eckigen Klammern vor dem Eigenschaften- oder Methodennamen hinzu. Weitere Informationen finden Sie unter Hinzufügen einer Eigenschaft und Erstellen einer Methode. Sie können diese Eigenschaften und Methoden mithilfe von MOF-Qualifizierern ändern. Weitere Informationen finden Sie unter Hinzufügen eines Qualifizierers.

Das folgende Codebeispiel zeigt, wie Eigenschaften und Methoden mit MOF-Qualifizierern geändert werden.
```
[read : ToSubClass, key : ToSubClass ] string DeviceID;
  [read : ToSubClass] uint32 State;
  [read : ToSubclass, write : ToSubClass] uint64 LimitUsers;
```
Speichern Sie die MOF-Datei mit der Erweiterung „.mof“.
Registrieren Sie die Klasse bei WMI, indem Sie Mofcomp.exe für die Datei ausführen.

mofcomp.exe newmof.mof

Wenn Sie den Schalter -N oder den Präprozessorbefehl „#pragma namespace“ nicht verwenden, um einen Namespace anzugeben, werden die kompilierten MOF-Klassen im Namespace „root\default“ im Repository gespeichert. Weitere Informationen finden Sie unter mofcomp.

Im folgenden Codebeispiel werden die in der vorherigen Prozedur erläuterten MOF-Codebeispiele kombiniert, und es wird und veranschaulicht, wie Sie eine Basisklasse im Namespace „root\cimv2“ mithilfe von MOF erstellen.

#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;
};

Weitere Informationen sowie ein Beispiel für eine von dieser Basisklasse abgeleiteten dynamischen Klasse finden Sie unter Erstellen einer abgeleiteten Klasse.

Erstellen einer Basisklasse mit C++

Das Erstellen einer Basisklasse mithilfe der WMI-API umfasst hauptsächlich eine Reihe von Put-Befehlen, die die Klasse definieren und die Klasse bei WMI registrieren. Der Hauptzweck dieser API besteht darin, Clientanwendungen das Erstellen von Basisklassen zu ermöglichen. Anbieter können diese API jedoch ebenfalls verwenden, um eine Basisklasse zu erstellen. Beispiel: Wenn beispielsweise glauben, dass der MOF-Code für Ihren Anbieter nicht ordnungsgemäß installiert wird, können Sie den Anbieter anweisen, die richtigen Klassen automatisch im WMI-Repository zu erstellen. Weitere Informationen zu Anbietern finden Sie unter Schreiben eines Klassenanbieters.

Hinweis

Der Code erfordert die ordnungsgemäße Kompilierung des folgenden Verweises.

#include <wbemidl.h>

Sie können eine neue Basisklasse programmgesteuert mithilfe der COM-API für WMI erstellen.

Erstellen einer neue Basisklasse mit der WMI-API

Rufen Sie eine Definition für die neue Klasse ab, indem Sie die IWbemServices::GetObject-Methode aufrufen, wobei der strObjectPath-Parameter auf einen Nullwert festgelegt ist.

Das folgende Codebeispiel zeigt, wie eine Definition für eine neue Klasse abgerufen wird.
```
IWbemServices* pSvc = 0;
IWbemContext* pCtx = 0;
IWbemClassObject* pNewClass = 0;
IWbemCallResult* pResult = 0;
HRESULT hRes = pSvc->GetObject(0, 0, pCtx, &pNewClass, &pResult);
```
Richten Sie einen Namen für die Klasse ein, indem Sie die Systemeigenschaft __CLASS mit einem Aufruf der IWbemClassObject::Put-Methode festlegen.

Im folgenden Codebeispiel wird gezeigt, wie die Klasse durch Festlegen der Systemeigenschaft __CLASS benannt wird.
```
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);
```
Erstellen Sie die Schlüsseleigenschaft oder -eigenschaften, indem Sie IWbemClassObject::Put aufrufen.

Im folgenden Codebeispiel wird das Erstellen der Index-Eigenschaft beschrieben, die in Schritt 4 als Schlüsseleigenschaft bezeichnet wird.
```
  BSTR KeyProp = SysAllocString(L"Index");
  pNewClass->Put(KeyProp, 0, NULL, CIM_STRING);
```

Fügen Sie den Schlüsselstandardqualifizierer an die Schlüsseleigenschaft an, indem Sie zuerst die IWbemClassObject::GetPropertyQualifierSet-Methode und dann die IWbemQualifierSet::Put-Methode aufrufen.

Das folgende Codebeispiel zeigt, wie sie den Schlüsselstandardqualifizierer an die Schlüsseleigenschaft anfügen.

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

Erstellen Sie andere Eigenschaften der Klasse mit IWbemClassObject::Put.

Im folgenden Codebeispiel wird das Erstellen zusätzlicher Eigenschaften beschrieben.

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

Registrieren Sie die neue Klasse, indem Sie IWbemServices::PutClass aufrufen.

Da Sie nach der Registrierung einer neuen Klasse keine Schlüssel und Indizes definieren können, stellen Sie sicher, dass Sie alle Ihre Eigenschaften definiert haben, bevor Sie PutClass aufrufen.

Im folgenden Codebeispiel wird beschrieben, wie eine neue Klasse registriert wird.
```
  hRes = pSvc->PutClass(pNewClass, 0, pCtx, &pResult);
  pNewClass->Release();
```

Im folgenden Codebeispiel werden die in der vorherigen Prozedur erläuterten WMI-Codebeispiele kombiniert, und die Erstellung einer Basisklasse mit der WMI-API wird veranschaulicht.

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

Erstellen einer Klasse

Freigeben über

Erstellen einer WMI-Basisklasse

Erstellen einer Basisklasse mithilfe von MOF

Erstellen einer Basisklasse mit C++

Feedback

Zusätzliche Ressourcen

Freigeben über

Erstellen einer WMI-Basisklasse

Erstellen einer Basisklasse mithilfe von MOF

Erstellen einer Basisklasse mit C++

Zugehörige Themen

Feedback

Zusätzliche Ressourcen