Partager via

Création d’une classe dérivée WMI

  • Article

La création d’une classe dérivée dans WMI est très similaire à la création d’une classe de base. Comme avec une classe de base, vous devez d’abord définir la classe dérivée, puis inscrire la classe dérivée auprès de WMI. La différence principale est que vous devez d’abord localiser la classe parente dont vous souhaitez dériver. Pour plus d’informations, consultez Écriture d’un fournisseur de classes et Écriture d’un fournisseur d’instances.

La méthode recommandée pour créer des classes pour un fournisseur est dans les fichiers format MOF (Managed Object Format). Plusieurs classes dérivées qui sont liées les unes aux autres doivent être regroupées dans un fichier MOF, ainsi que toutes les classes de base à partir desquelles elles dérivent des propriétés ou des méthodes. Si vous placez chaque classe dans un fichier MOF distinct, chaque fichier doit être compilé pour que le fournisseur puisse fonctionner correctement.

Après avoir créé votre classe, vous devez supprimer toutes les instances de votre classe avant de pouvoir effectuer l’une des activités suivantes sur votre classe dérivée :

  • Modifiez la classe parente de votre classe dérivée.
  • Ajouter ou supprimer des propriétés.
  • Apporter des changements aux types de propriété.
  • Ajouter ou supprimer les qualificateurs Key ou Indexed.
  • Ajoutez ou supprimez des qualificateurs Singleton, Dynamic ou Abstract.

Notes

Pour ajouter, supprimer ou modifier une propriété ou un qualificateur, appelez IWbemServices::P utClass ou SWbemObject.Put_ et définissez le paramètre d’indicateur sur « mode de force ». Le qualificateur Abstract ne peut être utilisé que si la classe parente est abstraite.

 

Lorsque vous déclarez votre classe dérivée, respectez les règles et restrictions suivantes :

  • La classe parente de la classe dérivée doit déjà exister.

    La déclaration de la classe parente peut apparaître dans le même fichier MOF que la classe dérivée ou dans un autre fichier. Si la classe parente est inconnue, le compilateur génère une erreur d’exécution.

  • Une classe dérivée ne peut avoir qu’une seule classe parente.

    WMI ne prend pas en charge l'héritage multiple. Toutefois, une classe parente peut avoir de nombreuses classes dérivées.

  • Vous pouvez définir des index pour les classes dérivées, mais WMI n’utilise pas ces index.

    Par conséquent, la spécification d’un index sur une classe dérivée n’améliore pas les performances des requêtes pour les instances de la classe dérivée. Vous pouvez améliorer les performances d’une requête sur une classe dérivée en spécifiant des propriétés indexées pour la classe parente de la classe dérivée.

  • Les définitions de classes dérivées peuvent être plus complexes et peuvent inclure des fonctionnalités telles que des alias, des qualificateurs et des saveurs de qualificateurs.

    Pour plus d’informations, consultez Création d’un alias et Ajout d’un qualificateur.

  • Si vous souhaitez modifier un qualificateur, modifier la valeur par défaut d’une propriété de classe de base ou taper plus fortement une référence ou une propriété d’objet incorporée d’une classe de base, vous devez déclarer à nouveau la classe de base entière.

  • Le nombre maximal de propriétés que vous pouvez définir dans une classe WMI est 1024.

Notes

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. La détection d’un changement de classe n’est actuellement pas possible.

 

Comme avec la classe de base, l’utilisation la plus courante de cette technique sera par les applications clientes. Toutefois, un fournisseur peut également créer une classe dérivée. Pour plus d’informations, consultez Création d’une classe de base et Écriture d’un fournisseur de classes.

L’exemple de code de cette rubrique nécessite la compilation correcte de l’instruction #include suivante.

#include <wbemidl.h>

La procédure suivante décrit comment créer une classe dérivée à l’aide de C++.

Pour créer une classe dérivée à l’aide de C++

  1. Recherchez la classe de base avec un appel à IWbemServices::GetObject.

    L'exemple de code suivant montre comment localiser l’exemple de la classe de base.

    // 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. Créez un objet dérivé à partir de la classe de base avec un appel à IWbemClassObject::SpawnDerivedClass.

    L’exemple de code suivant montre comment créer un objet de classe dérivé.

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

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

    L’exemple de code suivant montre comment attribuer un nom à la classe dérivée.

    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. Créez des propriétés supplémentaires avec IWbemClassObject::P ut.

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

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

  5. Enregistrez la nouvelle classe en appelant IWbemServices::P utClass.

    L’exemple de code suivant montre comment enregistrer la nouvelle classe dérivée.

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

L’exemple de code suivant combine les exemples de code décrits dans la procédure précédente pour décrire comment créer une classe dérivée à l’aide de l’API WMI.

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

La procédure suivante décrit comment définir une classe dérivée à l’aide du code MOF.

Pour définir une classe dérivée à l’aide du code MOF

  1. Définissez votre classe dérivée avec le mot clé Classe, suivi du nom de votre classe dérivée et du nom de la classe parente séparé par un signe deux-points.

    L’exemple de code suivant décrit une implémentation d’une classe dérivée.

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

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

  2. Lorsque vous avez terminé, compilez votre code MOF avec le compilateur MOF.

    Pour plus d’informations, consultez Compilation de fichiers MOF.

Création d’une classe