Partager via

Créer une classe de base WMI

  • Article

La manière recommandée de créer une nouvelle classe de base WMI pour un fournisseur WMI est dans un fichier Managed Object Format (MOF). Vous pouvez également créer une classe de base en utilisant l’API COM pour WMI. Bien que vous puissiez créer une classe de base ou dérivée dans un script, sans un fournisseur fournissant des données à la classe et à ses sous-classes, la classe n’est pas utile.

Les sections suivantes seront abordées dans cette rubrique :

Créer une classe de base en utilisant MOF

Les classes WMI reposent généralement sur l’héritage. Avant de créer une classe de base, vérifiez les classes du modèle d’information commun (CIM) disponibles auprès du Distributed Management Task Force (DMTF).

Si de nombreuses classes dérivées utiliseront les mêmes propriétés, mettez ces propriétés et méthodes dans votre classe de base. Le nombre maximum de propriétés que vous pouvez définir dans une classe WMI est de 1024.

Lors de la création d’une classe de base, respectez la liste suivante de directives pour les noms de classes :

  • Utilisez des lettres majuscules et minuscules.

  • Commencez un nom de classe par une lettre.

  • N’utilisez ni un trait de soulignement au début ni à la fin.

  • Définissez tous les autres caractères comme des lettres, des chiffres ou des traits de soulignement.

  • Utilisez une convention de nommage cohérente.

    Bien que non nécessaire, une bonne convention de nommage pour une classe est deux composants reliés par un trait de soulignement. Dans la mesure du possible, un nom de vendeur devrait constituer la première moitié du nom, et un nom de classe descriptif devrait être la seconde partie.

Remarque

Les classes ne peuvent pas être modifiées pendant l’exécution des fournisseurs. Vous devez arrêter l’activité, modifier la classe, puis redémarrer le service de gestion Windows. Il n’est actuellement pas possible de détecter un changement de classe.

 

Dans MOF, créez une classe de base en la nommant avec le mot-clé class mais sans indiquer de classe parente.

Pour créer une classe de base en utilisant le code MOF

  1. Utilisez le mot-clé class avec le nom de la nouvelle classe, suivi d’une paire d’accolades et d’un point-virgule. Ajoutez des propriétés et des méthodes pour la classe entre les accolades. L’exemple de code suivant est fourni.

    L’exemple de code suivant montre comment une classe de base doit être définie.

    class MyClass_BaseDisk
{
};

    L’exemple de code suivant montre une définition incorrecte d’une classe de base.

    class MyClass_BaseDisk : CIM_LogicalDisk
{
};

  2. Ajoutez tous les qualificateurs de classe avant le mot-clé class pour modifier la façon dont la classe est utilisée. Placez les qualificateurs entre crochets. Pour plus d’informations sur les qualificateurs de modification des classes, veuillez consulter la section Qualificateurs WMI. Utilisez le qualificateur Abstract pour indiquer que vous ne pouvez pas créer directement une instance de cette classe. Les classes abstraites sont souvent utilisées pour définir des propriétés ou des méthodes qui seront utilisées par plusieurs classes dérivées. Pour plus d’informations, veuillez consulter la section Création d’une classe dérivée.

    L’exemple de code suivant définit la classe comme abstraite et définit le fournisseur qui fournira les données. Le qualificateur ToSubClass flavor indique que les informations dans le qualificateur Provider sont héritées par les classes dérivées.

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

  3. Ajoutez les propriétés et méthodes de la classe entre crochets avant le nom de la propriété ou de la méthode. Pour plus d’informations, veuillez consulter les sections Ajout d’une propriété et Création d’une méthode. Vous pouvez modifier ces propriétés et méthodes en utilisant les qualificateurs MOF. Pour plus d’informations, veuillez consulter la section Ajouter un qualificateur.

    L’exemple de code suivant montre comment modifier des propriétés et des méthodes avec des qualificateurs MOF.

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

  4. Enregistrez le fichier MOF avec une extension .mof.

  5. Enregistrez la classe avec WMI en exécutant mofcomp.exe sur le fichier.

    mofcomp.exe newmof.mof

    Si vous n’utilisez pas l’option -N ou la commande de préprocesseur #pragma namespace pour spécifier un espace de noms, les classes MOF compilées seront stockées dans l’espace de noms root\default dans le référentiel. Pour plus d’informations, veuillez consulter la section mofcomp.

L’exemple de code suivant combine les exemples de code MOF discutés dans la procédure précédente et montre comment créer une classe de base dans l’espace de noms root\cimv2 en utilisant 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;
};

Pour plus d’informations, veuillez consulter la section Création d’une classe dérivée pour voir un exemple de classe dynamique dérivée de cette classe de base.

Créer une classe de base avec C++

Créer une classe de base en utilisant l’API WMI est principalement une série de commandes Put qui définissent la classe et enregistrent la classe avec WMI. L’objectif principal de cette API est de permettre aux applications clientes de créer des classes de base. Cependant, vous pouvez également avoir un fournisseur utiliser cette API pour créer une classe de base. Par exemple, si vous pensez que le code MOF de votre fournisseur ne sera pas installé correctement, vous pouvez demander à votre fournisseur de créer automatiquement les classes correctes dans le référentiel WMI. Pour plus d’informations sur les fournisseurs, veuillez consulter la section Écriture d’un fournisseur de classes.

Remarque

Les classes ne peuvent pas être modifiées pendant l’exécution des fournisseurs. Vous devez arrêter l’activité, modifier la classe, puis redémarrer le service de gestion Windows. Il n’est actuellement pas possible de détecter un changement de classe.

 

Le code nécessite la référence suivante pour compiler correctement.

#include <wbemidl.h>

Vous pouvez créer une nouvelle classe de base de manière programmatique en utilisant l’API COM pour WMI.

Pour créer une nouvelle classe de base avec l’API WMI

  1. Récupérez une définition pour la nouvelle classe en appelant la méthode IWbemServices::GetObject avec le paramètre strObjectPath défini sur une valeur null.

    L’exemple de code suivant montre comment récupérer une définition pour une nouvelle classe.

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

  2. Établissez un nom pour la classe en définissant la propriété système __CLASS avec un appel à la méthode IWbemClassObject::Put.

    L’exemple de code suivant montre comment nommer la classe en définissant la propriété système __CLASS.

    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. Créez la ou les propriétés clés en appelant IWbemClassObject::Put.

    L’exemple de code suivant décrit comment créer la propriété Index, qui est étiquetée comme une propriété clé à l’étape 4.

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

  4. Attachez le qualificateur standard Key à la propriété clé en appelant d’abord la méthode IWbemClassObject::GetPropertyQualifierSet puis la méthode IWbemQualifierSet::Put.

    L’exemple de code suivant montre comment attacher le qualificateur standard Key à la propriété clé.

      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. Créez d’autres propriétés de la classe avec IWbemClassObject::Put.

    L’exemple de code suivant décrit comment créer des propriétés supplémentaires.

      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. Enregistrez la nouvelle classe en appelant IWbemServices::PutClass.

    Étant donné que vous ne pouvez pas définir de clés et d’indices après avoir enregistré une nouvelle classe, assurez-vous d’avoir défini toutes vos propriétés avant d’appeler PutClass.

    L’exemple de code suivant décrit comment enregistrer une nouvelle classe.

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

L’exemple de code suivant combine les exemples de code discutés dans la procédure précédente et montre comment créer une classe de base en utilisant l’API WMI.

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

Création d’une classe