FAQ DelphiConsultez toutes les FAQ

1
2
3
Sous XP : 
C:\WINDOWS\system32\wbem\wbemdisp.tlb 
C:\WINDOWS\system32\wbem\wbemads.tlb (Pour manipuler Active Directory via WMI)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Var 
  WMILocator:          TSWbemLocator; 
  WmiService:          SWbemServices; 
  
  OldCursor:           TCursor; 
  
begin 
 WMILocator:= TSWbemLocator.Create(self); 
 try 
  OldCursor := Screen.Cursor; 
  Screen.Cursor := crSQLWait; 
  
  WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '', 
                                        '', wbemConnectFlagUseMaxWait, nil); 
 Finally 
  WMILocator.Free; 
  Screen.Cursor:= OldCursor; 
 end; 
end;

WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '','', wbemConnectFlagUseMaxWait, nil);

1
2
3
4
5
6
Var 
 NewProcess: Win32_Process; 
  
Begin 
 NewProcess:=Win32_Process.Create('Notepad.exe','c:\temp',Nil, ProcessId); 
End;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
procedure TForm1.BTConnexionClick(Sender: TObject); 
var 
  WmiService:          SWbemServices; 
  
  WmiObject:           SWbemObject; 
  wmiObjectSet:        SWbemObjectSet; 
  
  WmiObjectPath:       SWbemObjectPath; 
  
  ObjectEnumerator:    IEnumVariant; 
  ArrayVariant:        OleVariant;  // Tableau de variant 
  NumberItem:          LongWord; 
  
  ClasseList:           TStringList; 
begin 
try 
   WMILocator:= TSWbemLocator.Create(self); 
    // crée une liste pour le tri 
    // permet de comparer le résultat avec celui des outils WMI de MS 
  ClasseList := TStringList.Create; 
  ClasseList.Sorted:=True; 
  
  Memo1.Lines.Clear; 
   // Création d'une connexion à un espace de nom local 
   // ici le nom de l'espace de nom cible est : CIMV2 
   // L'appel renvoie un objet SWbemServices 
   WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '', 
                                         '', wbemConnectFlagUseMaxWait, nil); 
  
   // Retrouve la collection d'objet SWbemObject contenant toutes les sous-classes 
   // immédiates de l'espace de nom courant 
  WmiObjectSet:= WmiService.SubclassesOf('',wbemFlagReturnWhenComplete,Nil); 
                                           //+wbemQueryFlagShallow limite aux sous-Classes immédiates 
  
   // Affecte un énumérateur pour la collection d'objet SWbemObject 
  ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant; 
  
    // Retourne NumberItem éléments dans le tableau ArrayVariant, 
    // ici 1 élément est demandé 
  while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do 
  begin 
      // Récupère l'objet SWbemObject courant de la collection 
   WmiObject := IUnknown(ArrayVariant) as SWBemObject; 
      // Retrouve l'objet SWbemObjectPath contenant toutes les propriétés 
   WmiObjectPath:= WmiObject.Path_; 
      // retrouve le nom de la classe via le chemin d'accès relatif. 
   ClasseList.Add(WmiObjectPath.RelPath); 
  end; 
  Memo1.Lines.Assign(ClasseList); 
  Memo1.Lines.Add(#13#10+IntToStr(ClasseList.Count)+' Classes.'); 
  
 Finally 
  ClasseList.Free; 
 end; 
end;

Memo1.Lines.Add(AdjustLineBreaks(wmiObject.GetObjectText_(0)));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
procedure WMIEnumereProperty( WmiService:SWbemServices; WmiPropertySet: SWbemPropertySet; Liste: TStrings); 
//Enumère une collection et affiche pour chaque élément le nom de la propriété et son contenu. 
//Détermine si le qualificateur Key de la propriété existe. 
var 
  WmiProperty :   SWBemProperty; 
  Enumerateur:    IEnumVariant; 
  ArrayVariant:   OleVariant;  // Tableau de variant 
  NombreItem:     LongWord; 
  KeyQualificateur: String; 
  
begin 
  Enumerateur:= (WmiPropertySet._NewEnum) as IEnumVariant; 
  while (Enumerateur.Next(1, ArrayVariant, NombreItem) = S_OK) do 
   begin 
    WmiProperty := IUnknown(ArrayVariant) as SWBemProperty; 
    KeyQualificateur:=WMIGet_KeyQualifierOfProperty(WmiService,WmiProperty); 
    If KeyQualificateur<>'' 
     then Liste.add('Clé ['+KeyQualificateur+'] = '+ 
                          WmiPropertySet.Item(KeyQualificateur,0).Get_Value); 
    Liste.Add(AdjustLineBreaks('Propriété '+WmiProperty.name+' = '+ 
              WMIPropertyToStr(WmiService,WmiProperty))); 
   end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Function WMIGet_KeyQualifierOfProperty( WmiService:SWbemServices; WmiProperty: SWbemProperty):String; 
//Recherche pour une propriété le qualificateur KEY. 
//Cette clé déterminant l'unicité dans une classe d'association par exemple. 
  
begin 
 try 
  WmiProperty.Qualifiers_.Item('Key',0); 
  Result:=WmiProperty.name; // cette propriéte est une clé ( Key Qualifier) 
       // Une clé par propriété, mais plusieurs 
       // propriétés peuvent former une clé composée. 
 except 
  on E:EOleException do 
   Result:=''; 
 end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
procedure WMIEnumereQualificateur( WmiQualifierSet: SWbemQualifierSet; Liste: TStrings); 
//Enumère une collection et affiche, pour chaque élément, le nom du qualificateur et son contenu. 
  
var 
  WmiQualifier:   SWBemQualifier; 
  Enumerateur:    IEnumVariant; 
  ArrayVariant:   OleVariant;  // Tableau de variant 
  NombreItem:     LongWord; 
  
begin 
   Enumerateur:= (WmiQualifierSet._NewEnum) as IEnumVariant; 
   while (Enumerateur.Next(1, ArrayVariant, NombreItem) = S_OK) do 
   begin 
    WmiQualifier := IUnknown(ArrayVariant) as SWbemQualifier; 
      // Retrouve le nom et la valeur du qualificateur. 
    Liste.Add('Nom du Qualificateur : '+WmiQualifier.Name+'='+WMIVariantToStr(WmiQualifier.Get_Value) ); 
   end; 
end;

WMIEnumereQualificateur( WmiObject.Qualifiers_,Memo1.Lines);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
procedure WMIEnumereObjetRelPath( WmiObjectSet: SWbemObjectSet; Liste: TStrings); 
//Enumère une collection et affiche, pour chaque élément, le chemin relatif. 
var 
  WmiObject:      SWbemObject; 
  Enumerateur:    IEnumVariant; 
  ArrayVariant:   OleVariant; 
  NombreItem:     LongWord; 
  
begin 
  Enumerateur:= (WmiObjectSet._NewEnum) as IEnumVariant; 
  while (Enumerateur.Next(1, ArrayVariant, NombreItem) = S_OK) do 
  begin 
   WmiObject := IUnknown(ArrayVariant) as SWBemObject; 
      //Affiche au format MOF 
   Liste.Add(WmiObject.Path_.RelPath); 
  end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
Function WMIPropertyToStr(WmiService:SWbemServices; WmiProperty : SWbemProperty):String; 
//Convertit une propriété en chaîne de caractères. 
  
var sValue: String; 
    Count:  Integer; 
    Value: Variant; 
    WmiObjet : SWbemObject; 
  
begin 
 try 
    Value:=WmiProperty.Get_Value; 
    sValue := ''; 
    if VarIsNull(Value) then 
      sValue := 'Is Null' 
    else 
     try 
      case WmiProperty.CIMType of //Voir l'énumération WbemCimTypeEnum 
        wbemCimtypeSint8, 
        wbemCimtypeUint8, 
        wbemCimtypeSint16, 
        wbemCimtypeUint16, 
        wbemCimtypeSint32, 
        wbemCimtypeUint32, 
        wbemCimtypeSint64, 
        wbemCimtypeUint64: 
          if VarIsArray(Value) then begin 
            if VarArrayHighBound(Value, 1) > 0 then 
              for Count := 1 to VarArrayHighBound(Value, 1) do 
                sValue := sValue + ' ' + IntToStr(Value[Count]); 
          end 
          else 
            sValue := IntToStr(Value); 
  
        wbemCimtypeReal32, 
        wbemCimtypeReal64: 
          sValue := FloatToStr(Value); 
  
        wbemCimtypeBoolean: 
          if Value then sValue := 'True' else sValue := 'False'; 
  
          // Caractère unicode 16 bit au format de caractère universel Set–2 (UCS-2)  
        wbemCimtypeChar16, 
         // Chaîne de caractères unicode 
        wbemCimtypeString: 
          if VarIsArray(Value) then begin 
            if VarArrayHighBound(Value, 1) > 0 then 
              try 
              for Count := 1 to VarArrayHighBound(Value, 1) do 
                sValue := sValue + ' ' + Value[Count]; 
              except 
               on E: EConvertError do 
                 ShowMessage(E.Message); 
              end; 
          end 
          else 
            sValue := Value; 
  
        wbemCimtypeDatetime: 
          sValue := Value; 
          (* Voir note en fin de méthode *) 
        wbemCimtypeReference: begin 
                                // Récupére l'objet référencé 
                               WmiObjet:=WmiService.Get(Value,wbemFlagReturnWhenComplete,Nil); 
                               sValue:=AdjustLineBreaks(WmiObjet.GetObjectText_(0)) 
                              end; 
          (* Voir note en fin de méthode *) 
          //Renvoie le path de la propriété de type Objet 
        wbemCimtypeObject : begin 
                                 // Récupére l'objet imbriqué 
                                 // **Peut-il être un tableau d'objets ? 
                              WmiObjet:=IUnknown(WmiProperty.Get_Value) as SWbemObject ; 
                              sValue:=WmiObjet.Path_.Relpath; 
                           end; 
      end; // case 
     except 
      on E: EVariantError do 
       ShowMessage('WMIPropertyToStr : Erreur de conversion de variant'); 
     end; 
 Finally 
  Result:=sValue; 
 end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
procedure TForm1.BTConnexionClick(Sender: TObject); 
var 
  WMILocator:          TSWbemLocator; 
  WmiService:          SWbemServices; 
  
  WmiObject:           SWbemObject; 
  wmiObjectSet:        SWbemObjectSet; 
  
  ObjectEnumerator:    IEnumVariant; 
  ArrayVariant:        OleVariant;   
  NumberItem:          LongWord; 
  
begin 
  WMILocator:= TSWbemLocator.Create(self); 
 try 
   WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '', 
                                         '', wbemConnectFlagUseMaxWait, nil); 
  
   // Retrouve la collection d'instance de la classe Win32_OperatingSystem 
   // de l'espace de nom courant 
    wmiObjectSet := wmiService.InstancesOf('Win32_OperatingSystem', 
                                             wbemFlagReturnWhenComplete+wbemQueryFlagShallow, 
                                             nil); 
  
  ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant; 
  
  while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do 
  begin 
   WmiObject := IUnknown(ArrayVariant) as SWBemObject; 
  
      // Retrouve la propriété de l'instance au format MOF 
   Memo1.Lines.Add(AdjustLineBreaks(wmiObject.GetObjectText_(0))); 
  end; 
 Finally 
  WMILocator.Free; 
 end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
procedure TForm1.btInstancePartielClick(Sender: TObject); 
 // Retrouve une instance partielle 
var 
  WMILocator:          TSWbemLocator; 
  WmiService:          SWbemServices; 
  
  WmiObject:           SWbemObject; 
  
  WmiProperty:         SWbemProperty; 
  WmiPropertySet:      SWbemPropertySet; 
  
  WmiNamedValueSet:    TSWbemNamedValueSet; 
  
  PropertyEnumerator:  IEnumVariant; 
  ArrayVariant:        OleVariant; 
  NumberItem:          LongWord; 
  
  Value:               Olevariant; 
  
begin 
try 
  WMILocator:= TSWbemLocator.Create(self); 
  
   // Création d'une connexion à un espace de nom local 
   // ici le nom de l'espace de nom cible est : CIMV2 
   // L'appel renvoie un objet SWbemServices 
  WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '', 
                                         '', wbemConnectFlagUseMaxWait, nil); 
  
  WmiNamedValueSet:= TSWbemNamedValueSet.Create(self); 
  
  Value:=True; //Contenu de la valeur nommée 
   //'__GET_EXTENSIONS' signale une instance partielle 
  WmiNamedValueSet.Add('__GET_EXTENSIONS',Value,0); // iFlags toujours à zéro. 
  WmiNamedValueSet.Add('__GET_EXT_CLIENT_REQUEST',Value,0); 
  // WmiNamedValueSet.Add(' __GET_EXT_KEYS_ONLY',Value,0); //Renvoie seulement les clés 
  
   //Tableaux des propriétés à renvoyer 
  Value:=VarArrayCreate([1,2], varOleStr); 
  Value[1]:='Name'; 
  Value[2]:='State'; 
   //'__GET_EXT_PROPERTIES' indique la liste des propriétés à renvoyer 
  WmiNamedValueSet.Add('__GET_EXT_PROPERTIES',Value,0); 
  
   // Retrouve l'instance du service Telnet de la classe Win32_Service 
   // de l'espace de nom courant 
  WmiObject := wmiService.Get('Win32_Service.Name="TlntSvr"', 
                              0, 
                              WmiNamedValueSet.DefaultInterface); 
  
      // Retrouve la collection d'objets WmiProperty contenant toutes les propriétés 
   WmiPropertySet:= WmiObject.Properties_; 
   Memo1.Lines.Add(IntToStr(WmiPropertySet.Count)); 
      // Affecte un énumérateur pour la collection d'objets WmiProperty 
   PropertyEnumerator:= (WmiPropertySet._NewEnum) as IEnumVariant; 
  
   while (PropertyEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do 
   begin 
     // Récupére l'objet SWBemProperty courant de la collection 
    WmiProperty := IUnknown(ArrayVariant) as SWBemProperty; 
  
      // Retrouve le nom et la valeur de la propriété. 
   if not VarIsNull(WmiProperty.Get_Value) 
     then Memo1.Lines.Add(WmiProperty.name+'='+WMIPropertyToStr(WmiService,WmiProperty)); 
   end; 
  
 Finally 
  WmiNamedValueSet.Free; 
  WMILocator.Free; 
 end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
procedure TForm1.BTConnexionClick(Sender: TObject); 
var 
  WMILocator:          TSWbemLocator; 
  WmiService:          SWbemServices; 
  
  WmiObject:           SWbemObject; 
  wmiObjectSet:        SWbemObjectSet; 
  
  WmiProperty:         SWbemProperty; 
  WmiPropertySet:      SWbemPropertySet; 
  
  PropertyEnumerator, 
  ObjectEnumerator:    IEnumVariant; 
  ArrayVariant:        OleVariant;  // Tableau de variant 
  NumberItem:          LongWord; 
  
begin 
  WMILocator:= TSWbemLocator.Create(self); 
 try 
   WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '', 
                                         '', wbemConnectFlagUseMaxWait, nil); 
  
   // Retrouve la collection d'instances de la classe Win32_Service 
   // de l'espace de nom courant 
    wmiObjectSet := wmiService.InstancesOf('Win32_Service', 
                                             wbemFlagReturnWhenComplete+wbemQueryFlagShallow, 
                                             nil); 
  
  ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant; 
  
  while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do 
  begin 
   WmiObject := IUnknown(ArrayVariant) as SWBemObject; 
  
      // Retrouve la collection d'objets WmiProperty contenant toutes les propriétés 
   WmiPropertySet:= WmiObject.Properties_; 
      // Affecte un énumérateur pour la collection d'objet WmiProperty 
   PropertyEnumerator:= (WmiPropertySet._NewEnum) as IEnumVariant; 
  
     // Aprés l'affectation précédente, on peut réutiliser la variable ArrayVariant 
   while (PropertyEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do 
   begin 
     // Récupére l'objet SWBemProperty courant de la collection 
    WmiProperty := IUnknown(ArrayVariant) as SWBemProperty; 
  
       // Retrouve le nom du service via la propriété de classe nommée 'Name'. 
       // Implicite : propriété de type Chaine de caractéres. 
       //   WmiProperty.CIMType = wbemCimtypeString 
    If WmiProperty.name='Name' 
     then Memo1.Lines.Add(WmiProperty.Get_Value); 
   end; 
  end;  
 Finally 
  WMILocator.Free; 
 end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Affecte un énumérateur pour la collection d'objet SWbemObjectSet 
  ObjectEnumerator:=TEnumVariant.Create(wmiService.InstancesOf('systemrestore', 
                                             wbemFlagReturnWhenComplete+wbemQueryFlagShallow, 
                                             nil)); 
  
  For MonObjetWMI in ObjectEnumerator do 
  begin 
      // Affecte un énumérateur pour la collection d'objets SWbemPropertySet 
   PropertyEnumerator:= TEnumVariant.Create((MonObjetWMI as SWBemObject).Properties_); 
  
   For MaProprieteWMI in PropertyEnumerator do 
   begin 
       // Retrouve le nom du service via la propriété de classe nommée 'Name'. 
    With (MaProprieteWMI as SWBemProperty)  do 
     begin 
      If Name='Name' 
 ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
var  ProcessID:   OleVariant; //Variable Globale 
... 
procedure TForm1.BTCreateProcessClick(Sender: TObject); 
var 
  WMILocator : TSWbemLocator; 
  
  Process, 
  NewProcess, 
  Instance_inParameters : SWbemObject; 
  
  WmiProperty : SWbemProperty; 
  
  ProcessMethod : ISWbemMethod; 
  
  PropertyCommandLine, 
  PropertyReturnValue : OleVariant; 
  
begin 
  WMILocator:= TSWbemLocator.Create(self); 
 try 
   WmiService:= WMILocator.ConnectServer('.', 'ROOT\CIMV2', '', '', '', 
                                         '', wbemConnectFlagUseMaxWait, nil); 
  
    // Retrouve la définition de la classe Win32_Process 
   Process:=WmiService.Get('Win32_Process',0,Nil); 
  
    // Récupère, à partir de la collection de méthode, 
    // la définition de la méthode 'Create' de la classe Win32_Process 
   ProcessMethod:=Process.Methods_.Item('Create', 0); 
    // La définition de la méthode 'Create' correspond à  : 
          {    Win32_Process.Create(IN CommandLine string , 
                                    IN CurrentDirectory   string , 
                                    IN ProcessStartupInformation Win32_ProcessStartup , 
                                    OUT ProcessId uint32) 
              Valeur de retour : 
                  [Out] ProcessId uint32 ; 
                  [out] ReturnValue uint32 ; 
          } 
  
    // Crée une nouvelle instance de la méthode '.Create' de la classe Win32_Process 
    // alloue l'espace mémoire pour manipuler ces paramètres. 
    // ProcessMethod.InParameters.Properties_ contient la liste des paramètres de la méthode 
   Instance_inParameters:= ProcessMethod.InParameters.SpawnInstance_(0); 
  
    // L'appel suivant est possible : 
    //   NewInParametersInstance:= Process.Methods_.Item('Create',0).inParameters.SpawnInstance_(0); 
  
    // Retrouve la propriété 'CommandLine' de la méthode '.Create' 
   WmiProperty:= Instance_inParameters.Properties_.Item('CommandLine',0); 
     // Nom du programme à exécuter 
   PropertyCommandLine:= 'Notepad.exe'; 
    //Renseigne la valeur de la propriété 'CommandLine' de la méthode '.Create' 
   WmiProperty.Set_Value(PropertyCommandLine); 
  
    //Crée un process via la Méthode '.Create' 
   NewProcess:= Process.ExecMethod_('Create', Instance_inParameters, wbemFlagReturnWhenComplete, nil); 
  
   { Un objet OutParameters est créé par la méthode exécutée } 
  
    // Recupère la valeur de retour de la méthode via la propriété 'ReturnValue' 
   PropertyReturnValue:= NewProcess.Properties_.Item('ReturnValue', 0); 
   {Code de retour : 
     0 Successful completion 
     2 Access denied 
     3 Insufficient privilege 
     8 Unknown failure 
     9 Path not found 
     21 Invalid parameter 
    } 
  
   if PropertyReturnValue.Value = 0 then 
     begin 
       // Réutilise la propriété pour récupérer l'ID de process 
      PropertyReturnValue:= NewProcess.Properties_.Item('ProcessId', 0); 
      ProcessID:=PropertyReturnValue.Value; 
      MessageBox(0, PChar('Process crée.'+#10#13+'Pid : '+inttostr(ProcessID)), 
                 PChar(Form1.Caption), MB_OK); 
      BTDeleteProcess.Enabled:= True; 
      BTCreateProcess.Enabled:= False; 
      SetForegroundWindow(Form1.Handle); 
     end 
    else // Une erreur lors de la création du process 
     MessageBox(0, PChar('Erreur '+inttostr(PropertyReturnValue.Value)+' lors de la création du process.'), 
                PChar(Form1.Caption), MB_OK); 
 Finally 
  WMILocator.Free; 
 end; 
end;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
var 
  Instance_inParameters : SWbemObject; 
  WmiProperty : SWbemProperty; 
  ProcessMethod : ISWbemMethod; 
  PropertyReturnValue : OleVariant; 
  ObjectWmi, ParametreOut : SWBemObject; 
  PropertyReason : OleVariant; 
begin 
     // Retrouve une instance de la classe Win32_Process 
     // la propriété Handle est la clé de la classe 
    ObjectWmi:= WmiService.Get('Win32_Process.Handle="' + inttostr(ProcessId)+ '"', 0, nil); 
  
      // Retrouve la méthode Terminate 
    ProcessMethod:= ObjectWmi.Methods_.Item('Terminate', 0); 
    Instance_inParameters:= ProcessMethod.InParameters.SpawnInstance_(0); 
     // La méthode Terminate a 1 paramètre nommé Reason 
     //  Reason : [in] Exit code for the process and for all threads terminated as a result of this call. 
    WmiProperty:= Instance_inParameters.Properties_.Item('Reason',0); 
    PropertyReason:= 0; 
    WmiProperty.Set_Value(PropertyReason); 
  
     // Execute la méthode 
    ParametreOUT:= ObjectWmi.ExecMethod_('Terminate', Instance_inParameters, wbemFlagReturnWhenComplete, nil); 
     // Récupére le code de sortie 
    PropertyReturnValue:= ParametreOUT.Properties_.Item('ReturnValue', 0); 
    if PropertyReturnValue.Value = 0 then 
    begin 
      BTCreateProcess.Enabled:= True; 
      BTDeleteProcess.Enabled:= False; 
    end 
    else 
      MessageBox(0, PChar('Supression du process impossible.'), PChar(Form1.Caption), MB_OK); 
end;

1
2
//Ajoute au process appelant le privilège wbemPrivilegeShutdown (SE_SHUTDOWN_NAME) 
  wmiService.Security_.Privileges.Add(wbemPrivilegeShutdown, True);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
procedure TForm1.BtConnexionClick(Sender: TObject); 
  
var 
  WmiService:          SWbemServices; 
  
  WmiObjet:            SWbemObject; 
  wmiObjetSet:         SWbemObjectSet; 
  
  WmiProperty:         SWbemProperty; 
  
  ObjectEnumerator:    IEnumVariant; 
  ArrayVariant:        OleVariant;  // Tableau de Variant 
  NumberItem:          LongWord; 
  
  ShutdownMethod_inParameters, 
  Shutdown :           SWbemObject; 
  
  PropertyReboot :     OleVariant; 
  
  ShutdownMethod:      SWbemMethod; 
  
  WMILocator:          TSWbemLocator; 
  
begin 
 WMILocator:= TSWbemLocator.Create(self); 
    // Initialisation 
  try 
     //Permet aux objets d'utiliser l'identité de l'appelant.  
     //C'est le niveau d'usurpation d'identité recommandé  
     //pour l'appel d'API de scripting WMI. 
  WMILocator.Security_.Set_ImpersonationLevel(wbemImpersonationLevelImpersonate ); 
  
     //WMI utilise la configuration d'authentification par défaut de Windows. 
  WMILocator.Security_.Set_AuthenticationLevel(wbemAuthenticationLevelDefault); 
  
    // Attention aux majuscules-minuscules pour le password. 
  WmiService:= WMILocator.ConnectServer('NomDeMachine', 
                                        'ROOT\CIMV2',  
                                        'MonDomaine\MonCompte',  
                                         'PasswordDuCompte',  
                                         '', 
                                         '', 
                                         wbemConnectFlagUseMaxWait, 
                                         nil); 
  except 
   on E:EOleException do 
    begin 
     // S'il s'agit d'un problème de mot de passe E_ACCESSDENIED=$80070005  
     ShowMessage(StrOriginError(E.ErrorCode)+' ['+IntToHex(E.ErrorCode,8)+'] '+E.Message); 
     Raise; 
    end; 
  end; 
  
    //Ajoute au process appelant le privilège wbemPrivilegeShutdown (SE_SHUTDOWN_NAME) 
  wmiService.Security_.Privileges.Add(wbemPrivilegeShutdown, True); 
  
  wmiObjetSet := wmiService.ExecQuery( 
    'SELECT * FROM Win32_OperatingSystem WHERE Primary=True', 
    'WQL', wbemFlagReturnImmediately, nil); 
  
  ObjectEnumerator:= (WmiObjetSet._NewEnum) as IEnumVariant; 
  
  while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do 
  begin 
    WmiObjet := IUnknown(ArrayVariant) as SWBemObject; 
    ShutdownMethod:= wmiObjet.Methods_.Item('Win32Shutdown', 0); 
    ShutdownMethod_inParameters:= ShutdownMethod.InParameters; 
    Shutdown:= ShutdownMethod_inParameters.SpawnInstance_(0); 
    WmiProperty := Shutdown.Properties_.Add('Flags', wbemCimtypeSint32, False, 0); 
    PropertyReboot:= EWX_SHUTDOWN; // ou EWX_REBOOT; 
    wmiProperty.Set_Value(PropertyReboot); 
  
    wmiObjet.ExecMethod_('Win32Shutdown', Shutdown, 0, nil); 
  end; 
end;