Creazione di una classe di base WMI

Il modo consigliato per creare una nuova classe di base WMI per un provider WMI si trova in un file MOF (Managed Object Format). È anche possibile creare una classe di base usando l'API COM per WMI. Sebbene sia possibile creare una classe di base o derivata nello script, senza un provider che fornisce dati alla classe e alle relative sottoclassi, la classe non è utile.

Le sezioni seguenti sono descritte in questo argomento:

• Creazione di una classe base tramite MOF
• Creazione di una classe base con C++
• Argomenti correlati

Creazione di una classe base tramite MOF

Le classi WMI in genere si basano sull'ereditarietà. Prima di creare una classe di base, controllare le classi COMMON Information Model (CIM) disponibili in Distributed Management Task Force (DMTF).

Se molte classi derivate useranno le stesse proprietà, inserire queste proprietà e metodi nella classe di base. Il numero massimo di proprietà che è possibile definire in una classe WMI è 1024.

Quando si crea una classe base, osservare l'elenco seguente di linee guida per i nomi delle classi:

• Usare sia lettere maiuscole che minuscole.

• Iniziare un nome di classe con una lettera.

• Non usare un carattere di sottolineatura iniziale o finale.

• Definire tutti i caratteri rimanenti come lettere, cifre o caratteri di sottolineatura.

• Usare una convenzione di denominazione coerente.

  Sebbene non sia necessaria, una buona convenzione di denominazione per una classe è costituito da due componenti uniti da un carattere di sottolineatura. Quando possibile, un nome fornitore deve costituire la prima metà del nome e un nome descrittivo della classe deve essere la seconda parte.

In MOF creare una classe di base assegnandogli una denominazione con la parola chiave class , ma non indicando una classe padre.

Per creare una classe base usando il codice MOF

1. Usare la parola chiave class con il nome della nuova classe, seguita da una coppia di parentesi graffe e un punto e virgola. Aggiungere proprietà e metodi per la classe tra parentesi graffe. Viene fornito l'esempio di codice seguente.

   Nell'esempio di codice seguente viene illustrato come deve essere definita una classe base.

   class MyClass_BaseDisk
   {
   };
   

   Nell'esempio di codice seguente viene illustrata una definizione non corretta di una classe di base.

   class MyClass_BaseDisk : CIM_LogicalDisk
   {
   };
   

2. Aggiungere tutti i qualificatori di classe prima della parola chiave della classe per modificare il modo in cui viene usata la classe. Posizionare i qualificatori tra parentesi quadre. Per altre informazioni sui qualificatori per la modifica delle classi, vedere Qualificatori WMI. Usare il qualificatore Abstract per indicare che non è possibile creare direttamente un'istanza di questa classe. Le classi astratte vengono spesso usate per definire proprietà o metodi che verranno usati da diverse classi derivate. Per altre informazioni, vedere Creazione di una classe derivata.

   L'esempio di codice seguente definisce la classe come astratta e definisce il provider che fornirà i dati. Il sapore del qualificatore ToSubClass indica che le informazioni nel qualificatore provider sono ereditate dalle classi derivate.

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

3. Aggiungere le proprietà e i metodi per la classe tra parentesi quadre prima del nome della proprietà o del metodo. Per altre informazioni, vedere Aggiunta di una proprietà e Creazione di un metodo. È possibile modificare queste proprietà e metodi usando i qualificatori MOF. Per altre informazioni, vedere Aggiunta di un qualificatore.

   Nell'esempio di codice seguente viene illustrato come modificare proprietà e metodi con qualificatori MOF.

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

4. Salvare il file MOF con estensione mof.

5. Registrare la classe con WMI eseguendo Mofcomp.exe nel file.

   mofcomp.exe newmof.mof

   Se non si usa l'opzione -N o lo spazio dei nomi del preprocessore #pragma per specificare uno spazio dei nomi, le classi MOF compilate verranno archiviate nello spazio dei nomi root\default nel repository. Per altre informazioni, vedere mofcomp.

Nell'esempio di codice seguente vengono combinati gli esempi di codice MOF descritti nella procedura precedente e viene illustrato come creare una classe base nello spazio dei nomi root\cimv2 usando 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;
};

Per altre informazioni, vedere Creazione di una classe derivata per un esempio di classe dinamica derivata da questa classe di base.

Creazione di una classe base con C++

La creazione di una classe base tramite l'API WMI è principalmente una serie di comandi Put che definiscono la classe e registrano la classe con WMI. Lo scopo principale di questa API è consentire alle applicazioni client di creare classi di base. Tuttavia, è anche possibile avere un provider che usa questa API per creare una classe di base. Ad esempio, se si ritiene che il codice MOF per il provider non venga installato correttamente, è possibile indicare al provider di creare automaticamente le classi corrette nel repository WMI. Per altre informazioni sui provider, vedere Scrittura di un provider di classi.

Il codice richiede che il riferimento seguente venga compilato correttamente.

#include <wbemidl.h>

È possibile creare una nuova classe di base a livello di codice usando l'API COM per WMI.

Per creare una nuova classe di base con l'API WMI

1. Recuperare una definizione per la nuova classe chiamando il metodo IWbemServices::GetObject con il parametro strObjectPath impostato su un valore Null.

   Nell'esempio di codice seguente viene illustrato come recuperare una definizione per una nuova classe.

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

2. Stabilire un nome per la classe impostando la proprietà di sistema __CLASS con una chiamata al metodo IWbemClassObject::P ut .

   Nell'esempio di codice seguente viene illustrato come assegnare un nome alla classe impostando la proprietà di sistema __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. Creare la proprietà o le proprietà della chiave chiamando IWbemClassObject::P ut.

   Nell'esempio di codice seguente viene descritto come creare la proprietà Index , etichettata come proprietà chiave nel passaggio 4.

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

4. Collegare il qualificatore standard Key alla proprietà key chiamando prima il metodo IWbemClassObject::GetPropertyQualifierSet e quindi il metodo IWbemQualifierSet::P ut.

   Nell'esempio di codice seguente viene illustrato come collegare il qualificatore standard Key alla proprietà 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);
   

5. Creare altre proprietà della classe con IWbemClassObject::P ut.

   Nell'esempio di codice seguente viene descritto come creare proprietà aggiuntive.

     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. Registrare la nuova classe chiamando IWbemServices::P utClass.

   Poiché non è possibile definire chiavi e indici dopo aver registrato una nuova classe, assicurarsi di aver definito tutte le proprietà prima di chiamare PutClass.

   Nell'esempio di codice seguente viene descritto come registrare una nuova classe.

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

Nell'esempio di codice seguente vengono combinati gli esempi di codice descritti nella procedura precedente e viene illustrato come creare una classe di base usando 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();
}

Argomenti correlati

Creazione di una classe