Bon, je vais vous expliquer à manipuler la base de registre grâce au API VB, évidemment, ceux qui ne savent pas ce qu'est Regedit sont dans le gaz, donc je vais vous faire un cours express sur ce que vous avez besoin de savoir, tout d'abord, pour ouvrir Regedit, vous devez aller dans Démarrer > exécuter et tapez Regedit, puis Entrer, là Regedit s'ouvre, si cela ne marche pas, allez dans démarrer > exécuter et tapez regedt32.exe, là cela devrait fonctionner, alors là vous voyez apparaître des fenêtres contenant plein de dossier, je ne vais pas vous expliquer ce que représentent ces dossiers, ce n'est pas le sujet du site ! Tout ce que vous avez besoin de savoir, c'est qu'il y a 5 dossier (appelés clé) importante, celle-ci sont :

HKEY_CLASSES_ROOT
HKEY_CURRENT_USER
HKEY_LOCAL_MACHINE
HKEY_USERS
HKEY_DYN_DATA

Et dans chacune de ses clés se trouvent d'autre clés (les petits dossier), et comme les dossier Windows, les clés contiennent des fichiers (appelées valeur), elles peuvent être binaire, DWORD ou valeur de chaînes, ici je vais vous expliquer la manipulation pour les valeurs de chaînes (les plus courantes). Bon tout les mots de vocabulaire expliqué, nous allons pouvoir commencer le cours ! Tout d'abord, commencez un nouveau programme et insérez-y 6 boutons avec leur propriété Caption sur :

Créer clé, Supprimer clé, Créer valeur, Supprimer valeur, Lire valeurs et Quitter.

Bon maintenant, nous devons déclarer les API pour les manipulations du registre. Bon, vous devez d'abord déclarer celui pour la création de clés :

Private Declare Function RegCreateKey Lib "advapi32.dll" Alias "RegCreateKeyA" (ByVal HKey As Long, ByVal lpSubKey As String, phkResult As Long) As Long

Déclaration privée ( Private ) d'une fonction ( Function ) appelée RegCreateKey ( RegCreateKey ) se trouvant dans la bibliothèque advapi32.dll ( Lib "advapi32.dll" ), avec comme alias RegCreateKeyA ( Alias "RegCreateKeyA" ), avec comme argument HKey et phkResult étant du type Long et lpSubKey étant une chaîne de caractère ( (ByVal HKey As Long, ByVal lpSubKey As String, phkResult As Long) ), cette fonction renvoyant un entier long ( As Long ). Ensuite, nous devons déclarer l'API pour supprimer une clé :

Private Declare Function RegDeleteKey Lib "advapi32.dll" Alias "RegDeleteKeyA" (ByVal HKey As Long, ByVal lpSubKey As String) As Long

Déclaration privée ( Private ) d'une fonction ( Function ) appelée RegDeleteKey ( RegDeleteKey ) se trouvant dans la bibliothèque advapi32.dll ( Lib "advapi32.dll" ), avec comme alias RegDeleteKeyA ( Alias " RegDeleteKeyA" ), avec comme argument HKey étant du type Long et lpSubKey étant une chaîne de caractère ( (ByVal HKey As Long, ByVal lpSubKey As String) ), cette fonction renvoyant un entier long ( As Long ). Ensuite, nous devons déclarer l'API pour créer/donner une valeur à une valeur chaîne :

Private Declare Function RegSetValueEx Lib "advapi32.dll" Alias "RegSetValueExA" (ByVal HKey As Long, ByVal lpValueName As String, ByVal Reserved As Long, ByVal dwType As Long, ByVal lpData As Any, ByVal cbData As Long) As Long

Ben oui, c'est long ! C'est une déclaration privée ( Private ) d'une fonction ( Function ) appelée RegSetValueEx ( RegSetValueEx ) se trouvant dans la bibliothèque advapi32.dll ( Lib "advapi32.dll" ), avec comme alias RegSetValueEx A ( Alias " RegSetValueExA" ), avec comme argument HKey, Reserved, dwType et cbData étant du type Long, lpValueName étant une chaîne de caractère et lpData étant du type Any ( (ByVal HKey As Long, ByVal lpValueName As String, ByVal Reserved As Long, ByVal dwType As Long, ByVal lpData As Any, ByVal cbData As Long) ), cette fonction renvoyant un entier long ( As Long ). Ensuite, nous devons déclarer l'API pour supprimer une valeur chaîne :

Private Declare Function RegDeleteValue Lib "advapi32.dll" Alias "RegDeleteValueA" (ByVal HKey As Long, ByVal lpSubKey As String) As Long

Tout de suite, c'est moins long !!! C'est une déclaration privée ( Private ) d'une fonction ( Function ) appelée RegDeleteValue ( RegDeleteValue ) se trouvant dans la bibliothèque advapi32.dll ( Lib "advapi32.dll" ), avec comme alias RegDeleteValueA ( Alias " RegDeleteValueA" ), avec comme argument HKey étant du type Long et lpSubKey étant du type String (chaîne de caractère) ( (ByVal HKey As Long, ByVal lpSubKey As String) ), cette fonction renvoyant un entier long ( As Long ). Enfin, nous devons déclarer l'API pour lire une valeur chaîne :

Private Declare Function RegQueryValueEx Lib "advapi32.dll" Alias "RegQueryValueExA" (ByVal HKey As Long, ByVal lpValueName As String, ByVal lpReserved As Long, lpType As Long, lpData As Any, lpcbData As Long) As Long

Courage, c'est le dernier !!! C'est une déclaration privée ( Private ) d'une fonction ( Function ) appelée RegQueryValueEx ( RegQueryValueEx ) se trouvant dans la bibliothèque advapi32.dll ( Lib "advapi32.dll" ), avec comme alias RegQueryValueExA ( Alias " RegQueryValueExA" ), avec comme argument HKey, lpReserved, lpType et lpcbData étant du type Long, lpValueName étant du type String (chaîne de caractère) et lpData étant du type Any (donc ca peut être de n'importe quel type) ( (ByVal HKey As Long, ByVal lpValueName As String, ByVal lpReserved As Long, lpType As Long, lpData As Any, lpcbData As Long) ), cette fonction renvoyant un entier long ( As Long ).

Ouf ! Ca c'est de la déclaration d'API. Bon, comme vous vous en doutez, si par exemple, nous voulons créer une clé, il faut dire où cette clé sera désignée, donc il faut par exemple taper :

HKEY_CURRENT_USERchemin

Mais le truc, c'est que ce chemin ne s'écrit pas tout bêtement, le mot HKEY_CURRENT_USER définissant la clé principale est en fait une constante, car le vrai chemin serait :

&H80000001chemin

Ce que vous devez savoir, c'est que chemin peut être remplacé par une chemin d'accès genre Windows genre :

HKEY_CURRENT_USER\clé1\salut\hey\bonjour

Vous comprenez ? Evidemment vous ne savez pas que HKEY_CURRENT_USER, c'est égal à &H80000001 et moi non plus d'ailleurs et je ne le retiendrai pas, car dans la visionneuse, vous avez moyen de trouver les 5 valeurs de ces constantes, donc les constantes à déclarer sont :

Const HKEY_CLASSES_ROOT = &H80000000<br /> Const HKEY_CURRENT_USER = &H80000001<br /> Const HKEY_LOCAL_MACHINE = &H80000002<br /> Const HKEY_USERS = &H80000003<br /> Const HKEY_DYN_DATA = &H80000004

Pour finir, nous devons déclarer la variable lng comme étant long !

Dim Buff As Long

Donc pour créer une clé, c'est l'API RegCreateKey. Double-cliquez donc sur le premier bouton et tapez :

RegCreateKey HKEY_CURRENT_USER, "Salut", lng

Cette fonction est très simple. En fait, l'écriture théorique de cet APi est :

RegCreateKey clé_principale, Chemin, variable

La seule chose que vous pouvez ne pas comprendre est variable, en fait vous verrez que pour la lecture d'une valeur, cette variable est nécessaire ! Donc en tapant la ligne de commande ci-dessus, vous créer une clé à l'endroit HKEY_CURRENT_USERSalut. Double-cliquez maintenant sur le bouton Supprimer une clé et tapez :

RegDeleteKey HKEY_CURRENT_USER, "Salut"

Alors là, c'est encore plus simple. La structure théorique de cette fonction est :

RegDeleteKey clé_principale, Chemin

Voilà, donc, l'instruction tapée ci dessus, veut en fait dire qu'on va supprimer la clé HKEY_CURRENT_USERSalut. Double-cliquez sur le bouton Créer valeur et tapez :

RegCreateKey HKEY_CURRENT_USER, "Salut", lng RegSetValueEx lng, "Hey", 0&, 1, "Bijour", Len("Bijour") + 1

Ah ! Ca se complique ! Bon imaginons que vous voulez créer un objet dans un endroit ( c'est vague ...). Il faut que l'endroit existe pour pouvoir créer l'objet, en VB c'est la même chose, pour créer une valeur dans une clé, il faut que cette clé existe, donc avant de créer la valeur on créer la clé, alors là vous allez me dire :

Imaginez que nous voulons créer une valeur dans une clé contenant déjà des valeurs, en créant la clé pour enregistrer notre valeur, on va écraser les valeurs se trouvant dedans ...

Et moi je vous réponds Non, car en VB si vous créer un clé qui existe déjà, ben la clé ne se crée pas (logique puisqu'elle existe déjà !!!). Donc revenons à notre code ! Donc la première ligne créer la clé où sera stockée notre valeur ! Passons maintenant à la deuxième ligne !

RegSetValueEx lng, "Hey", 0&, 1, "Bijour", Len("Bijour") + 1

O_O. Ca doit être la tête que vous faites pour l'instant lol ! En fait, cette ligne est très facile !!! Tout d'abord, comme je vous le disais il est nécessaire de créer la clé avant d'enregistrer une valeur dedans rien que pour récupérer son handle (moyen d'authentification). Avec la ligne :

RegCreateKey HKEY_CURRENT_USER, "Salut", lng

Nous stockons le handle de la clé HKEY_CURRENT_USERSalut dans la variable lng. Donc avec la commence pour créer la valeur, vous avez compris que le premier argument (lng) désigne le handle du chemin où la valeur devra être créée ! Ensuite, nous avons le deuxième argument ("Hey"), alors là, c'est pas compliqué, c'est bêtement le nom de la clé !!!, puis nous avons l'argument 0&, qui doit TOUJOURS être nul. Ensuite, nous avons 1, cela veut dire que la chose crée sera une valeur chaîne, ensuite, nous avons "Bijour", c'est la valeur que contiendra votre valeur chaîne et pour finir, on a Len("Bijour") + 1, c'est fait pour indiquer la taille de votre valeur et c'est longueur doit toujours être égal à la longueur de votre chaîne + un caractère qui sera un caractère null. Bon, voilà, la valeur est crée. Nous allons maintenant apprendre à la supprimer (c'est pas logique comme marche à suivre, mais vu que c'est compliqué pour la lire, je fais du plus facile au plus compliqué !). Double-cliquez sur le bouton Supprimer valeur et tapez :

RegCreateKey HKEY_CURRENT_USER, "Salut", lng RegDeleteValue lng, "Hey"

Bon ! Comme pour la création de valeur il faut déterminé si le chemin d'où se trouve la clé existe, donc nous créons cette clé pour cela ! Et comme vous le savez, lng recevra le handle de la clé, alors une fois ce handle acquérit, il faut supprimer la clé en tapant dans le premier argument le handle de la clé où se trouve la valeur à supprimer et dans le deuxième argument le nom de la clé à supprimer. Bon !!! Maintenant, le plus dur, la lecture des clés !!! Aussi bizarre que cela puisse paraître, la lecture ne peut s'effectuer que par un appel de fonction ! Cela ne marche pas dans une Sub !!! Nous devons donc créer la fonction, tapez dans un endroit libre de votre feuille de code :

Private Function LireValeur(HK, Chemin As String, Valeur As String) As String Buff = 0 Buff = RegCreateKey(HK, Chemin, lng) If Buff = 0 Then RegQueryValueEx lng, Valeur, 0&, 1, 0&, Buff If Buff < 1 Then MsgBox "Clé introuvable !", vbInformation + vbOKOnly, "Erreur" Exit Function End If LireValeur = String(Buff, " ") RegQueryValueEx lng, "Hey", 0&, 1, ByVal LireValeur, Buff LireValeur = Left(LireValeur, Buff - 1) MsgBox "La valeur vaut : " & LireValeur, vbInformation + vbOKOnly, "Valeur" End Function

Tout d'abord, nous créons la fonction LireValeur acceptant 3 argument, HK étant le nom de la clé principale, Chemin étant le chemin de la clé à lire et Valeur étant le nom de la valeur à lire ! Bon, tout d'abord, avant de vous expliquer la suite, je vais vous donner le code pour le bouton Lire Valeur :

LireValeur HKEY_CURRENT_USER, "Salut", "Hey"

On appelle la fonction LireValeur. Donc comme vous le savez, quand on appelle la fonction ainsi, dans la fonction tout les HK seront remplacés (en exécution je parle) par HKEY_CURRENT_USE , les Chemin par "Salut" et les valeur par "Hey" . Bon, revenons à la fonction, la première ligne initialise la variable Buff à 0, ça c'est pas dur ! Bon ensuite, nous avons la ligne :

Buff = RegCreateKey(HK, Chemin, lng)

En fait, cela place dans la variable Buff le résultat de la fonction RegCreateKey, en fait, Buff prendra la valeur 0 si la clé existe bien ! Sinon elle prendra un valeur positive différente de 0. Donc après nous disons :

If Buff = 0 Then RegQueryValueEx lng, Valeur, 0&, 1, 0&, Buff If Buff < 1 Then MsgBox "Clé introuvable !", vbInformation + vbOKOnly, "Erreur" Exit Function End If

Cela est une "bête" boucle If. Elle dit que si la variable Buff est égale à 0 (donc si la clé existe bien, il faut lire cette clé, en tapant dans le premier argument de la fonction de lecture le handle de la clé ou se trouve la valeur à lire, dans le deuxième arguments le nom de la valeur à lire, le troisième argument doit toujours etre nul, le quatrième argument indique que c'est une valeur chaîne qu'il faut lire, les 5ème élément doit être nul et le dernier argument indique la variable qui contiendra la taille de la valeur chaîne. Ensuite, nous faisons une autre boucle If en disant que si Buff est plus petit que 1, donc que la clé n'existe pas, une msgbox s'affiche et la fonction se termine. Bon imaginons que la clé existe donc que la fonction ne soit pas quitté prématurément, nous arrivons à la ligne :

LireValeur = String(Buff, " ")

Cela place le caractère espace un certain nombre de fois dans une chaîne de caractère, donc, si vous souvenez, Buff contient maintenant le nombre de caractère que contient la valeur de la valeur chaîne. Donc si Buff vaut 7, la variable LireValeur vaudra : "       ". En fait, nous créons la valeur pour contenir le texte de la valeur chaîne et nous devons préparer la variable qui contiendra ce texte.

RegQueryValueEx lng, "Hey", 0&, 1, ByVal LireValeur, Buff

Cette fonction lire la valeur dont la position est défini par la variable lng (handle de la clé), ensuite, dans le 2ème argument, nous indiquons le nom de la valeur à lire, ensuite, le 3ème élément doit être nul, le 4ème désigne que la valeur à lire est une valeur chaîne, ensuite, le 5ème argument désigne que la valeur de la valeur chaîne sera stocké dans la variable LireValeur et le ByVal désigne, qu'il prend la chaîne et place la variable dedans, mais en remplaçant seulement les caractère nécessaire, donc si la variable LireValeur avant contient " ", et que la chaîne à mettre est Bijour, ben la valeur LireValeur après vaudra : "Bijour ". Voilà, ensuite, Buff récupère la taille de cette chaîne. Vous avez maintenant la ligne :

LireValeur = Left(LireValeur, Buff - 1)

Comme vous le savez, une valeur récupérée par un API se termine souvent avec un espace nul à la fin qu'il faut supprimer au cas où vous voudriez ajouter du texte après cette valeur. Donc il faut transformer cette chaîne, nous faisons cela grâce à l'instruction Left. Donc dans ce cas, nous prenons tout le texte de la variable LireValeur sauf le dernier caractère, si vous ne comprenez pas, rapellez-vous que Buff est une variable contenant le nombre de caractère que vous chaîne comporte ! Et pour finir, nous avons cette ligne :

MsgBox "La valeur vaut : " & LireValeur, vbInformation + vbOKOnly, "Valeur"

Cette ligne, vous devriez la comprendre, elle affiche simplement une MsgBox, avec le message :

La valeur vaut : avec la valeur de la valeur chaîne.

Voilà, mon cours est terminé, j'ai essayé de faire du mieux que je pouvais car c'est vraiment compliqué de faire un cours sur ce sujet ! Je tiens seulement à remercier Zak, qui m'a donné le code pour utiliser la base de registre, sans ce code, j'aurais beaucoup plus longtemps à comprendre l'utilisation du registre ! Si vous ne comprenez pas tout, veuillez en parler avec moi avec mon adresse zick@areaprog.com (on ne se moque pas ^^). Je suis assez souvent sur Internet et je me forcerais de répondre à vos questions !!! Ah ! J'allais oubliez, le plus dur :

Double-cliquez sur le bouton Quitter et tapez :

End