Creazione di una classe base WMI
Il modo consigliato per creare una nuova classe di base WMI per un provider WMI è in un file MOF (Managed Object Format). È anche possibile creare una classe di base usando l'API COM per WMI. Anche se è 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 illustrate in questo argomento:
- Creazione di una classe di base tramite MOF
- Creazione di una classe base con C++
- Argomenti correlati
Creazione di una classe di base tramite MOF
Le classi WMI si basano in genere sull'ereditarietà. Prima di creare una classe di base, controllare le classi Common Information Model (CIM) disponibili da Distributed Management Task Force (DMTF).
Se molte classi derivate useranno le stesse proprietà, inserire queste proprietà e metodi nella classe base. Il numero massimo di proprietà che è possibile definire in una classe WMI è 1024.
Quando si crea una classe di base, osservare l'elenco seguente di linee guida per i nomi delle classi:
Usare lettere maiuscole e 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.
Anche se non è necessario, una buona convenzione di denominazione per una classe è due componenti aggiunti 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.
Nota
Le classi non possono essere modificate durante l'esecuzione di provider. È necessario arrestare l'attività, modificare la classe e quindi riavviare il servizio Gestione Windows. Il rilevamento di una modifica della classe non è attualmente possibile.
In MOF creare una classe di base assegnandole una denominazione con la parola chiave della classe , ma non indicando una classe padre.
Per creare una classe di base usando il codice MOF
Usare la parola chiave della classe 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 le parentesi graffe. Viene fornito l'esempio di codice seguente.
Nell'esempio di codice seguente viene illustrato come deve essere definita una classe di base.
class MyClass_BaseDisk { };Nell'esempio di codice seguente viene illustrata una definizione errata di una classe di base.
class MyClass_BaseDisk : CIM_LogicalDisk { };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 Astratta 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 { };Aggiungere le proprietà e i metodi per la classe all'interno delle parentesi quadre prima della proprietà o del nome 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;Salvare il file MOF con estensione mof.
Registrare la classe con WMI eseguendo Mofcomp.exe nel file.
mofcomp.exenewmof.mof
Se non si usa l'opzione -N o il comando preprocessore #pragma spazio dei nomi per specificare uno spazio dei nomi, le classi MOF compilate verranno archiviate nello spazio dei nomi radice\predefinito 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 di 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 di base usando 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.
Nota
Le classi non possono essere modificate durante l'esecuzione di provider. È necessario arrestare l'attività, modificare la classe e quindi riavviare il servizio Gestione Windows. Il rilevamento di una modifica della classe non è attualmente possibile.
Il codice richiede il riferimento seguente per la compilazione corretta.
#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
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);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);Creare la proprietà o le proprietà 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);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);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);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
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per