[WMI] Modifier propriétés

Version imprimable

Voir 40 message(s) de cette discussion en une page

11/05/2007, 16h42
Laurent Dardenne

Citation:

Envoyé par BATiViR

Je peux trouver ou SDK WMI?

ici http://msdn2.microsoft.com/en-us/library/aa394582.aspx
Essai Google la prochaine fois...

Citation:

Envoyé par BATiViR

je ne pas me baser sur mon code non??

?
Désolé, je ne parle pas le gromello couramment :mouarf:

Citation:

Envoyé par BATiViR

Et pour changer le mot de passe sa a l'aire d'être totalement different,

Oui, et pourquoi à ton avis ? :aie:
14/05/2007, 09h36
BATiViR

Sais-tu vers où je devrais commencer a chercher cette fonction?? Google ne m'as pas trouver grand chose...

Citation:

Envoyé par BATiViR

Sais-tu vers où je devrais commencer a chercher cette fonction?? Google ne m'as pas trouver grand chose...

De quelle fonction tu parles ?
De la modification du password d'un compte ?

as-tu remarqué que l'instruction suivante ne référence pas un espace de nom WMI connu (ex : root\CMV2) ?

Code:

GetObject("WinNT://" & strPCName & "/Administrator")

en recherchant GetObject("WinNT:// ,on trouve ceci http://www.15seconds.com/issue/020130.htm

On peut donc supposer qu'il s'agit d'ADSI, extrait du tuto sur WMI :

Citation:

La librairie C:\WINDOWS\system32\wbem\wbemads.tlb propose quant à elle les extensions WMI ADSI (Active Directory Services Interface) permettant de gérer les accès à Active Directory. Elle propose un seul composant :
TWMIExtension

Description : WMI Extension to DS 1.0 Type Library (Version 1.0)

Qui elle propose l'objet IWMIExtension::GetWMIObject, en cherchant dans le SDK

Donc en Delphi ça nous donne
Code:

1 2 3 4 5 6 7 8 IWMIExtension = interface(IDispatch) ['{ADC1F06E-5C7E-11D2-8B74-00104B2AFB41}'] function Get_WMIObjectPath: WideString; safecall; function GetWMIObject: ISWbemObject; safecall; function GetWMIServices: ISWbemServices; safecall; property WMIObjectPath: WideString read Get_WMIObjectPath; end;
Essai de renseigner la propriété WMIObjectPath puis appel la méthode GetWMIObject.
Tu récupére un objet de la classe (WMI ?) IADsUser qui porte une methode setpasswordmais là je ne connais pas suffisament AD, regarde aussi du coté de activeDS.dll

Je n'ai pas fait le test mais je procèderais ainsi.
[edit]
En recherchant 10 mn (getobject And WMI and Delphi) on tombe sur se site pui en filtrant sur (getobject) on tombe sur ça :
http://www.delphipraxis.net/topic101...ight=getobject
Il y a un lien US qui répond parfaitement à ton pb.

Encore un petit problème, enfin j'espère :
J'aimerai changer de domaine (par exemple) et cette méthode nécessite plusieurs paramètres, ce qui est normale : password administrateur + user du serveur active directory... Ma fonction fonctionne parfaitement quand je dois changer un paramètre... Voila le lien msdn http://msdn2.microsoft.com/en-us/library/aa392154.aspx et voila ma fonction comme dit plus haut sa va surment servir à quelqu'un :

Code:

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
function SetWMI(Requete, Method, vType, Value, Condition :String; ConditionExit :Integer) :Integer;
var
  WMIService            : SWbemServices;
  WMILocator            : ISWbemLocator;
 
  Instance_inParameters : SWbemObject;
 
  WMIProperty           : SWbemProperty;
 
  ProcessMethod         : ISWbemMethod;
 
  WMIObject             : SWbemObject;
  MethodeResultat       : SWbemObject;
  WMIObjectSet          : SWbemObjectSet;
 
  PropertyProdKey,
  PropertyReturnValue   : OleVariant;
 
  ObjectEnumerator:    IEnumVariant;
  ArrayVariant:        OleVariant;
  NumberItem:          LongWord;
begin
  Screen.Cursor := crAppStart;
  WMILocator:= CoSWbemLocator.Create;
  WMIService:= WMILocator.ConnectServer(sPCName, 'ROOT\CIMV2', sUserName, sUserPwd, '',
                                         '', wbemConnectFlagUseMaxWait, Nil);
  WMIObjectSet := WMIService.ExecQuery(Requete, 'WQL',
                                        wbemFlagReturnImmediately, Nil);
  ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant;
  while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do
  begin
    WMIObject := IUnknown(ArrayVariant) as SWBemObject;
    if Condition <> '' Then
    begin
      PropertyReturnValue:= WMIObject.Properties_.Item(Condition, 0);
      if PropertyReturnValue.Value = ConditionExit Then
      begin
        Screen.Cursor:= crDefault;
        result := -1;
        Exit;
      end;
    end;
    ProcessMethod:=WmiObject.Methods_.Item(Method, 0);
    Instance_inParameters:= ProcessMethod.InParameters.SpawnInstance_(0);
    WMIProperty:= Instance_inParameters.Properties_.Item(vType,0);
    PropertyProdKey:= Value;
    //Renseigne la valeur de la propriété
    WMIProperty.Set_Value(PropertyProdKey);
    MethodeResultat:= WmiObject.ExecMethod_(Method, Instance_inParameters, wbemFlagReturnWhenComplete, nil);
 
    // Recupére la valeur de retour de la méthode via la propriété 'ReturnValue'
    PropertyReturnValue:= MethodeResultat.Properties_.Item('ReturnValue', 0);
  end;
  result := PropertyReturnValue.Value;
  Screen.Cursor:= crDefault;
end;

et voila un exemple pour changer le nom du pc

Code:

1
2
3
4
5
6
7
8
9
10
    Result := SetWMI('Select * From Win32_ComputerSystem', 'Rename', 'Name', 'NomDuPC', '', 0);
    if Result = 0 Then
    begin
      MessageBox(0, PChar('Nom de l''ordinateur changé avec succès!'), '', MB_OK);  
    end
    else begin
      MessageBox(0, PChar('Une erreur est survenue, impossible de changer le nom de l''ordinateur : Error '
                            + IntToStr(Result)), '', MB_OK);
    end;
  end;

Vous n'êtes pas obliger de mettre une condition si jamais et je pense que je vais la retirer de la fonction... Si quelqu'un voit comment changer plusieurs propriétés, merci d'avance :king:

23/05/2007, 11h04
BATiViR

Laurent Dardenne pourrais-tu m'aider une dernière foie??

En fesant quelques essai et en cherchant sur google j'ai enfin réussi a changer plusieurs propriétées. Voila mon ancienne fonction mit à jour

Code:

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
89
90
91
92
 
Function SetWMI(Requete, Method, vType, Value :String) :Integer;
var
  WMIService            : SWbemServices;
  WMILocator            : ISWbemLocator;
 
  Instance_inParameters : SWbemObject;
 
  WMIProperty           : SWbemProperty;
 
  ProcessMethod         : ISWbemMethod;
 
  WMIObject             : SWbemObject;
  MethodResult          : SWbemObject;
  WMIObjectSet          : SWbemObjectSet;
 
  vValue,
  PropertyReturnValue   : OleVariant;
 
  slType, slValue       : TStringList;
 
  ObjectEnumerator      : IEnumVariant;
  ArrayVariant          : OleVariant;
  NumberItem            : LongWord;
  i                     : integer;
begin
  Screen.Cursor := crAppStart;
  slType  := TStringList.Create;
  slValue := TStringList.Create;
 
  WMILocator := CoSWbemLocator.Create;
  WMIService := WMILocator.ConnectServer(sPCName, 'ROOT\CIMV2', sUserName, sUserPwd, '',
                                         '', wbemConnectFlagUseMaxWait, Nil);
  Try
    WMIObjectSet := WMIService.ExecQuery(Requete, 'WQL',
                                        wbemFlagReturnImmediately, Nil);
    ObjectEnumerator := (WMIObjectSet._NewEnum) as IEnumVariant;
    while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do
    begin
      WMIObject := IUnknown(ArrayVariant) as SWBemObject;
      ProcessMethod := WMIObject.Methods_.Item(Method, 0);
      Instance_inParameters := ProcessMethod.InParameters.SpawnInstance_(0);
 
        slType := ExtractWord(vType,[',']);
        slValue := ExtractWord(Value,[',']);
        for i:=0 to slType.count-1 do
        begin
          WMIProperty := Instance_inParameters.Properties_.Item(slType[i],0);
          vValue := slValue[i];
          //Renseigne la valeur de la propriété
          WMIProperty.Set_Value(vValue);
        end;
 
      MethodResult := WMIObject.ExecMethod_(Method, Instance_inParameters, wbemFlagReturnWhenComplete, nil);
 
      // Recupére la valeur de retour de la méthode via la propriété 'ReturnValue'
      PropertyReturnValue := MethodResult.Properties_.Item('ReturnValue', 0);
    end;
    Result := PropertyReturnValue.Value;
  Except
    // Si valeur entrée génère Exception ou Violation d'accès Erreur -222
    Result := -222;
  end;
  Screen.Cursor:= crDefault;
  slType.Free;
  slValue.Free;
end;
 
Function ExtractWord(sWords : string; sSeparateur : TSysCharSet): TStringList;
var
  i, n : integer; 
  CurrentWord : string;
begin
  Result := TStringList.Create;
  n := length(sWords);
  i := 1;
  while (i <= n) do
  begin
    currentWord := '';
    { on saute les séparateurs  }
    while (i <= n) and (sWords[i] in sSeparateur) do
      inc(i);
    { récupération du mot courant  }
    while (i <= n) and not (sWords[i] in sSeparateur) do
    begin
      CurrentWord := CurrentWord + sWords[i];
      inc(i);
    end; 
    if (CurrentWord <> '') then
      Result.Add(CurrentWord);
  end;
end;

Il y a deux fonction car la deuxieme me sert a extraire les paramètres et les valeurs séparées par une virgule. Voila un exemple pour changer de domaine :

Code:

1
2
3
4
5
6
7
 
var result :integer;
begin
Result := SetWMI('Select * From Win32_ComputerSystem', 'JoinDomainOrWorkgroup', 'Name,Password,UserName,FJoinOptions', 'NomDuDomaine,MotDePasse,NomUtilisateur,1');
  if Result <> 0 Then
MessageBox(0, PChar('Une erreur est survenue : Error '
                            + IntToStr(Result)), 'Erreur', MB_OK);

Si vous voyez une erreur ou quelque chose qui pourrait être simplifier faite le moi savoir :yaisse2:

28/05/2007, 17h00
Laurent Dardenne

Salut,
tu vois c'était pas le mer à boire.

J'ai réfléchi un peu à ton pb et je pense qu'il est préférable de créer une classe Delphi par classe WMI manipulée, c'est plus verbeux mais bien plus lisible donc maintenable.

Certaines méthodes utilisent des propriétés de type classe WMI (cf. WIN32_Share), d'autres peuvent être constituées de reférence de classe WMI ou encore renvoyer un résultat de type différent.

Et pour finir ton approche ne gére pas les paramétres en IN/OUT.
Je n'ai pas trop le temps pour vérifier mais si ta boucle while renvoi plusieurs instances tu appelleras la méthode sur chacune d'elle, c'est bien ce que tu souhaites faire ?

Quel est exactement l'erreur -222 ?

Sinon ça me semble correct.
29/05/2007, 10h06
BATiViR

Bein enfaite je me suis appuyer sur ce bou de code que j'ai trouver sur la FAQ http://www.developpez.com/delphi/faq...chierseventlog, il fait set_value chaque valeur et après fait un Put_ et moi un ExecMethod_ ... Je croix que cela est correct, en tout cas je ne peux pas faire un set_value et un ExecMethod a chaque foie, il faut que je le fasse après tout les set_value non?

Bein les IN sont les vType et les OUT j'utilise ReturnValue ce qui me renvoie l'erreur... Je n'ai pas encore ue l'utilité d'utiliser les autres...

Pour l'erreur -222, je l'ai mit en dure si il me renvoie une erreur de type erreur générique, ... Enfaite si il me renvoie cette erreur il n'a pas fini de modifier la method :aie: Je n'aime pas trop comment j'ai fai cela alors si t'as une meilleur solution ;)

Merci pour tout, tu m'as vraiment beaucoup aider, et je commence a comprendre la chose :king:

que veux-tu dire par

Citation:

créer une classe Delphi par classe WMI manipulée

??
29/05/2007, 12h42
Laurent Dardenne

Citation:

Envoyé par BATiViR

il faut que je le fasse après tout les set_value non ?

Oui sur ce point je suis d'accord avec toi.

Citation:

Envoyé par BATiViR

Je n'ai pas encore eu l'utilité d'utiliser les autres
...
Je n'aime pas trop comment j'ai fai cela alors si t'as une meilleur solution

Pas pour le moment, je voulais juste te signaler ce que je considére comme un défaut d'analyse sur ce sujet.

Citation:

Envoyé par BATiViR

je commence a comprendre la chose

J'espére pour toi :lol:

Citation:

Envoyé par BATiViR

que veux-tu dire par

J'aurais dû utiliser le terme d'encapsuler :
je pense qu'il est préférable d'encapsuler chaque classe WMI manipulée dans une classe Delphi.

Par exemple : ce type de classes porteraient ces propres informations et la classe ancêtre serait dédiée à l'appel des méthodes des classes dérivées. Donc Une approche plus objet que procédurale.
05/06/2007, 17h05
BATiViR

J'ai encore un problème et besoin d'aide encore cette foie :aie: J'aimerai arrêter un service avec ma fonction mais j'ai une erreur violation d'accès quand j'arrive à

Code:

Instance_inParameters := ProcessMethod.InParameters.SpawnInstance_(0);

de ma fonction SetWMI !! Je ne comprend pas pourquoi alors si quelqu'un ou toi Laurent Dardenne t'aurais la raison de pourquoi cela merci d'avance :yaisse2:
Voila le lien msdn pour démarrer un service http://msdn2.microsoft.com/en-US/library/aa393660.aspx et avec ma fonction je fai par exemple

Code:

SetWMI('Select * From Win32_Service WHERE Name = "Messenger"', 'StartService', 'StartService', '');
05/06/2007, 19h59
Laurent Dardenne

Salut,

Citation:

Envoyé par BATiViR

Laurent Dardenne t'aurais la raison de pourquoi cela merci d'avance

là il te reste juste à assumer ta démarche :bug:

Une piste : Assert ...
:aie:
06/06/2007, 09h44
BATiViR

D'après ce que j'ai lu je ne voi pas comment cela pourrais m'aider a trouver une solution :roll: Peutetre que je n'ai pas bien compris comment l'utiliser en tout cas après des heures de recherche sur internet je n'ai toujours pas trouver de solution :(

J'ai trouver des composants Delphi 2006 qui effectue tout cela http://www.online-admin.com/, la version shareware n'as pas limitations mais elle ne peut pas être utilisée en but commercial.

Ma fonction lecture des propriétées et modification marche plus ou moin bien mais ne gère pas bien les erreurs et dès que l'on veut (d'après ce que j'essai de faire) modifier quelque chose d'un peut différent cela devient vite long a la recherche et les raisons imcompréhensibles (pour ma part, débutant).

Je crois que je vais me pencher vers ces composants, d'après les exemples modifier les propriétés ou les lires est très simple.

La fonction lecture des info via WMI marche très bien, les choses ce compliquent quand on veut les modifier. Voila liste des infos que j'ai essayer et réussi a modifer.

Code:

1
2
3
4
5
6
Result := SetWMI('Select * From Win32_ComputerSystem', 'Rename', 'Name', 'NouveauNomPC');
Result := SetWMI('Select * From Win32_ComputerSystem', 'JoinDomainOrWorkgroup', 'Name,FJoinOptions',
                      PChar('NomDuDomaine' + ',' + '1'));
Result := SetWMI('Select * From Win32_ComputerSystem', 'JoinDomainOrWorkgroup', 'Name', PChar('GroupeDeTravail'));
Result := setWMI('SELECT * FROM Win32_WindowsProductActivation', 'SetProductKey', 'ProductKey',
                  PChar('XXXXX-XXXXX-XXXXX-XXXXX-XXXXX'));

Je n'ai pas réussi a modifier le statut des services, l'adresse IP, DNS, .... Jespère que ces exemples servirons à quelqu'un... :king: Merci pour vos réponses, m'as vraiment beaucoup aider.

Voila les fonctions :

Code:

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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
// Fonction lecture infos WMI
// InfoWMI('Nom de l'instance Win32_...', 'Nom de la propriété')
function InfoWMI(Requete, Properties : String) :TStringList;
var
  WMILocator:          TSWbemLocator;
  WMIService:          SWbemServices;
  WMIObjectSet:        SWbemObjectSet;
  WMIObject:           SWbemObject;
 
  ObjectEnumerator:    IEnumVariant;
 
  ArrayVariant:        OleVariant;
  NumberItem:          LongWord;
begin
  Result := TStringList.create;
  DNS2 := TStringList.create;
  WMILocator:= TSWbemLocator.Create(nil);
  Screen.Cursor := crAppStart;
  Try
    // Connexion WMI (PCName, 'ROOT\CIMV2', UserName, UserPassword, '', '', ...)
    WMIService:= WMILocator.ConnectServer(sPCName, 'ROOT\CIMV2', sUserName, sUserPwd, '',
                                          '', wbemConnectFlagUseMaxWait, nil);
 
    WMIObjectSet := WMIService.InstancesOf(Requete,
                                            wbemFlagReturnWhenComplete, nil);
    // Affecte un énumérateur pour la collection d'objet SWbemObject
    ObjectEnumerator:= (WmiObjectSet._NewEnum) as IEnumVariant;
 
    // Retourne NumberItem éléments dans le tableau ArrayVariant
    while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do
    begin
      // Récupére de la collection l'objet SWbemObject courant
      WMIObject := IUnknown(ArrayVariant) as SWBemObject;
      If WmiObject.Properties_.Item(Properties,0) <> nil Then
      begin
        if not VarIsNull(WmiObject.Properties_.Item(Properties, 0).Get_Value) Then
        begin
          if WmiObject.Properties_.Item(Properties,0).IsArray Then
          begin
            if not VarArrayHighBound(WmiObject.Properties_.Item(Properties,0).Get_Value, 1) > 0 Then
            begin
              // Retrouve la propriétés de l'instance au format MOF
              result.add(WmiObject.Properties_.Item(Properties,0).Get_Value[0]);
              if(Properties = 'DNSServerSearchOrder') Then DNS2.add('');
            end
            else
            begin
              result.add(WmiObject.Properties_.Item(Properties,0).Get_Value[0]);
              if(Properties = 'DNSServerSearchOrder') Then
              begin
                if VarArrayHighBound(WmiObject.Properties_.Item(Properties,0).Get_Value, 1) > 0 Then
                  DNS2.add(WmiObject.Properties_.Item(Properties,0).Get_Value[1])
                else DNS2.add('');
              end;
            end;
          end
          else
          begin
            // Retrouve la propriétés de l'instance au format MOF
            result.add(WMIObject.Properties_.Item(Properties,0).Get_Value)
          end;
        end
        else
        begin
          result.add('');
          if(Properties = 'DNSServerSearchOrder') Then DNS2.add('');
        end;
      end;
    end;
  Finally;
    Screen.Cursor:= crDefault;
    WMILocator.Disconnect;
    WMILocator.Free;
  end;
end;
 
Function SetWMI(Requete, Method, vType, Value :String) :Integer;
var
  WMIService            : SWbemServices;
  WMILocator            : ISWbemLocator;
 
  Instance_inParameters : SWbemObject;
 
  WMIProperty           : SWbemProperty;
 
  ProcessMethod         : ISWbemMethod;
 
  WMIObject             : SWbemObject;
  MethodResult          : SWbemObject;
  WMIObjectSet          : SWbemObjectSet;
 
  vValue,
  PropertyReturnValue   : OleVariant;
 
  slType, slValue       : TStringList;
 
  ObjectEnumerator      : IEnumVariant;
  ArrayVariant          : OleVariant;
  NumberItem            : LongWord;
  i                     : integer;
begin
  Screen.Cursor := crAppStart;
  slType  := TStringList.Create;
  slValue := TStringList.Create;
 
  WMILocator := CoSWbemLocator.Create;
  WMIService := WMILocator.ConnectServer(sPCName, 'ROOT\CIMV2', sUserName, sUserPwd, '',
                                         '', wbemConnectFlagUseMaxWait, Nil);
  Try
    WMIObjectSet := WMIService.ExecQuery(Requete, 'WQL',
                                        wbemFlagReturnImmediately, Nil);
    ObjectEnumerator := (WMIObjectSet._NewEnum) as IEnumVariant;
    while (ObjectEnumerator.Next(1, ArrayVariant, NumberItem) = S_OK) do
    begin
      WMIObject := IUnknown(ArrayVariant) as SWBemObject;
      ProcessMethod := WMIObject.Methods_.Item(Method, 0);
      Instance_inParameters := ProcessMethod.InParameters.SpawnInstance_(0);
 
      slType := ExtractWord(vType,[',']);
      slValue := ExtractWord(Value,[',']);
      if slType.count = slValue.count Then
      begin
        for i:=0 to slType.count-1 do
        begin
          WMIProperty := Instance_inParameters.Properties_.Item(slType[i],0);
          vValue := slValue[i];
          //Renseigne la valeur de la propriété
          WMIProperty.Set_Value(vValue);
        end;
        MethodResult := WMIObject.ExecMethod_(Method, Instance_inParameters, wbemFlagReturnWhenComplete, nil);
        // Recupére la valeur de retour de la méthode via la propriété 'ReturnValue'
        PropertyReturnValue := MethodResult.Properties_.Item('ReturnValue', 0);
      end;
    end;
    Result := PropertyReturnValue.Value;
  Except
    // Si valeur entrée génère Exception ou Violation d'accès Erreur -222
    Result := -222;
  end;
  Screen.Cursor:= crDefault;
  slType.Free;
  slValue.Free;
end;
 
Function ExtractWord(sWords : string; sSeparateur : TSysCharSet): TStringList;
var
  i, n : integer; 
  CurrentWord : string;
begin
  Result := TStringList.Create;
  n := length(sWords);
  i := 1;
  while (i <= n) do
  begin
    currentWord := '';
    { on saute les séparateurs  }
    while (i <= n) and (sWords[i] in sSeparateur) do
      inc(i);
    { récupération du mot courant  }
    while (i <= n) and not (sWords[i] in sSeparateur) do
    begin
      CurrentWord := CurrentWord + sWords[i];
      inc(i);
    end; 
    if (CurrentWord <> '') then
      Result.Add(CurrentWord);
  end;
end;
 
// Executer commande a distance
Function ExecProcess(Requete, Method, vType, Value : String): Integer;
var
  WMIService            : SWbemServices;
  WMILocator            : ISWbemLocator;
 
  Instance_inParameters : SWbemObject;
 
  WMIProperty           : SWbemProperty;
 
  ProcessMethod         : ISWbemMethod;
 
  WMIObject             : SWbemObject;
  MethodResult          : SWbemObject;
 
  vValue,
  PropertyReturnValue   : OleVariant;
begin
  Screen.Cursor := crAppStart;
  WMILocator := CoSWbemLocator.Create;
  WMIService := WMILocator.ConnectServer(sPCName, 'ROOT\CIMV2', sUserName, sUserPwd, '',
                                         '', wbemConnectFlagUseMaxWait, Nil);
  WMIObject := WMIService.Get(Requete, 0, Nil);
 
  ProcessMethod := WMIObject.Methods_.Item(Method, 0);
 
  Instance_inParameters:= ProcessMethod.InParameters.SpawnInstance_(0);
  WMIProperty := Instance_inParameters.Properties_.Item(vType,0);
 
 
  vValue := Value;
  WMIProperty.Set_Value(vValue);
  MethodResult := WMIObject.ExecMethod_(Method, Instance_inParameters, wbemFlagReturnWhenComplete, nil);
 
  // Recupére la valeur de retour de la méthode via la propriété 'ReturnValue'
  PropertyReturnValue := MethodResult.Properties_.Item('ReturnValue', 0);
 
  Result := PropertyReturnValue;
  Screen.Cursor:= crDefault;
end;

06/06/2007, 14h44
Laurent Dardenne

Le code dont tu t'es inspiré est un code de démo qui ne considére pas tout les cas d'erreurs.
Par exemple une requête WQL peut trés bien ne rien renvoyer, il est donc bien de s'en assurer avant d'aller plus loin dans le traitement.
Messenger peut ne pas être installé ou encore le service WMI peut ne pas être démarré.

Voir 40 message(s) de cette discussion en une page