Creazione di una classe derivata WMI

La creazione di una classe derivata in WMI è molto simile alla creazione di una classe di base. Come per una classe di base, è prima necessario definire la classe derivata e quindi registrare la classe derivata con WMI. La differenza principale è che è necessario individuare prima la classe padre da cui si desidera derivare. Per altre informazioni, vedere Scrittura di un provider di classi e scrittura di un provider di istanze.

Il modo consigliato per creare classi per un provider è nei file MOF (Managed Object Format). Diverse classi derivate correlate tra loro devono essere raggruppate in un file MOF, insieme a tutte le classi di base da cui derivano proprietà o metodi. Se si inserisce ogni classe in un file MOF separato, ogni file deve essere compilato prima che il provider possa funzionare correttamente.

Dopo aver creato la classe, è necessario eliminare tutte le istanze della classe prima di poter eseguire una delle attività seguenti nella classe derivata:

• Modificare la classe padre della classe derivata.
• Aggiungere o rimuovere proprietà.
• Modificare i tipi di proprietà.
• Aggiungere o rimuovere qualificatori chiave o indicizzati .
• Aggiungere o rimuovere qualificatori Singleton, Dinamici o Astratti .

Quando si dichiara la classe derivata, osservare le regole e le restrizioni seguenti:

• La classe padre della classe derivata deve già esistere.

  La dichiarazione della classe padre può essere visualizzata nello stesso file MOF della classe derivata o in un file diverso. Se la classe padre è sconosciuta, il compilatore genera un errore di runtime.

• Una classe derivata può avere solo una singola classe padre.

  WMI non supporta più ereditarietà. Tuttavia, una classe padre può avere molte classi derivate.

• È possibile definire indici per le classi derivate, ma WMI non usa questi indici.

  Pertanto, la specifica di un indice in una classe derivata non migliora le prestazioni delle query per le istanze della classe derivata. È possibile migliorare le prestazioni di una query in una classe derivata specificando proprietà indicizzate per la classe padre della classe derivata.

• Le definizioni di classi derivate possono essere più complesse e possono includere funzionalità come alias, qualificatori e sapori qualificatori.

  Per altre informazioni, vedere Creazione di un alias e Aggiunta di un qualificatore.

• Se si vuole modificare un qualificatore, modificare il valore predefinito di una proprietà della classe di base o digitare più fortemente una proprietà di riferimento o di oggetto incorporata di una classe di base, è necessario dichiarare nuovamente l'intera classe di base.

• Il numero massimo di proprietà che è possibile definire in una classe WMI è 1024.

Come per la classe di base, l'uso più comune di questa tecnica sarà da applicazioni client. Tuttavia, un provider può anche creare una classe derivata. Per altre informazioni, vedere Creazione di una classe di base e scrittura di un provider di classi.

L'esempio di codice in questo argomento richiede la compilazione corretta dell'istruzione #include seguente.

#include <wbemidl.h>

La procedura seguente descrive come creare una classe derivata usando C++.

Per creare una classe derivata usando C++

1. Individuare la classe di base con una chiamata a IWbemServices::GetObject.

   Nell'esempio di codice seguente viene illustrato come individuare la classe base Di esempio.

   // 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. Creare un oggetto derivato dalla classe base con una chiamata a IWbemClassObject::SpawnDerivedClass.

   Nell'esempio di codice seguente viene illustrato come creare un oggetto classe derivato.

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

3. 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 derivata.

   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. Creare proprietà aggiuntive con IWbemClassObject::P ut.

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

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

5. Salvare la nuova classe chiamando IWbemServices::P utClass.

   Nell'esempio di codice seguente viene illustrato come salvare la nuova classe derivata.

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

Nell'esempio di codice seguente vengono combinati gli esempi di codice descritti nella procedura precedente per descrivere come creare una classe derivata usando 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 procedura seguente descrive come definire una classe derivata usando il codice MOF.

Per definire una classe derivata usando il codice MOF

1. Definire la classe derivata con la parola chiave Class , seguita dal nome della classe derivata e dal nome della classe padre separata da due punti.

   Nell'esempio di codice seguente viene descritta un'implementazione di una classe derivata.

   class MyClass 
   {
       [key] string   strProp;
       sint32   dwProp1;
       uint32       dwProp2;
   };
   
   class MyDerivedClass : MyClass
   {
       string   strDerivedProp;
       sint32   dwDerivedProp;
   };
   

2. Al termine, compilare il codice MOF con il compilatore MOF.

   Per altre informazioni, vedere Compilazione di file MOF.

Argomenti correlati

Creazione di una classe