Vous êtes actuellement hors ligne, en attente de reconnexion à Internet.

COMMENT FAIRE : Utiliser l'API du registre pour enregistrer et récupérer des définitions de valeurs

Ancien nº de publication de cet article : F145679
Résumé
Bien que Visual Basic inclue les fonctions SaveSetting et GetSetting pour enregistrer et récupérer des informations du registre, ces fonctions n'opèrent que sur une section spécifique du registre, les paramètres de programme Visual Basic et VBA de la clé racine HKEY_CURRENT_USER.

Cet article décrit l'utilisation des fonctions API (Application Programming Interface) Windows 32 bits, qui permettent de définir et de récupérer des valeurs à partir de n'importe quelle section du registre. Les rubriques et références de fonction dans cet article peuvent être généralisées pour programmer le registre 16 bits.

Les fonctions API 32 bits incluent également la prise en charge de la sécurité, mais ceci dépasse la portée de ce document.

REMARQUE : Les fonctions SaveSetting et GetSetting ne font pas partie de la bibliothèque de fonctions VBA. Cependant, l'exemple de code ci-dessous est tout de même applicable aux applications 32 bits qui implémentent VBA.
Plus d'informations

Informations générales concernant le registre

Le registre est utilisé par les applications et par Windows pour stocker des données de configuration. Il remplace le grand nombre de fichiers INI qui proliféraient sur les ordinateurs Windows 3.x, et est aussi largement utilisé par OLE.

Le registre est structuré en une série hiérarchique de clés et de valeurs sous forme d'arborescence. Chaque clé, qui commence par l'une des six clés racines prédéfinies, peut être associée à plusieurs sous-clés et valeurs. Les clés sont des unités d'organisation et d'appellation qui apparaissent dans les Éditeurs de registre Windows sous forme de dossiers de fichiers. Les valeurs sont des entrées de données qui apparaissent comme entrées de texte dans le volet droit de la fenêtre de l'Éditeur du registre. La quantité de valeurs associées à une clé peut être nulle comme elle peut être élevée. Chaque valeur est associée à un type de données. Les deux types de données de registre les plus couramment utilisés sont REG_SZ, une chaîne à terminaison nulle, et REG_DWORD, un chiffre 32 bits.

Le processus de base employé pour écrire ou lire à partir d'un emplacement du registre est le même. Pour référencer une clé ou une valeur donnée, vous devez obtenir le descripteur de la clé. Une fois ce descripteur obtenu, les valeurs et sous-clés auxquelles ce descripteur fait référence peuvent être lues, définies ou listées (énumérées).

Pour un emplacement du registre donné, pour obtenir le descripteur de cette clé vous devez commencer par l'une des six clés prédéfinies (HKEY_CLASSES_ROOT, HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CURRENT_CONFIG et HKEY_DYN_DATA), puis développer l'arborescence du registre jusqu'à atteindre la clé recherchée. Les programmes utilisateur lisent et écrivent le plus souvent à partir de HKEY_CURRENT_USER et HKEY_LOCAL_MACHINE. Si les clés traversées existent déjà, vous pouvez utiliser une série d'appels aux fonctions RegOpenKey et RegOpenKeyEx. Si les clés doivent être créées, cette opération est assurée par les fonctions RegCreateKey et RegCreateKeyEx.

Avec le descripteur de la clé souhaitée, les fonctions utilisées pour lister, définir et récupérer des informations peuvent être appelées. Dans tous les cas, les fonctions avec le suffixe Ex ne fonctionneront que sur les plates-formes 32 bits. Les fonctions sans ce suffixe peuvent fonctionner sur les versions 16 bits et 32 bits de Windows. Il convient de garder à l'esprit que les fonctions du registre non affectées du suffixe 'Ex' ne sont pas toutes fournies à des fins de compatibilité 16 bits. Ce suffixe n'a été ajouté que lorsque les capacités de compatibilité 16 bits ont été étendues. Les fonctions entièrement nouvelles et spécifiques aux plates-formes 32 bits ne possèdent pas l'extension Ex.

Les fonctions RegSetValue et RegSetValueEx permettent de modifier la définition d'une valeur, tandis que RegQueryValue et RegQueryValueEx récupèrent la définition actuelle d'une valeur. Les limitations des versions 16 bits non-Ex de ces API sont ici évidentes. Lors de l'utilisation de la fonction RegSetValue 16 bits, il n'y a aucun moyen de nommer une valeur ; cette fonction ne peut donc être utilisée pour associer plus d'une valeur à chaque clé. De plus, toutes les valeurs écrites avec RegSetValue ont REG_SZ comme type de données. Ces limitations sont inhérentes au registre 16 bits. RegSetValueEx permet de créer plusieurs valeurs avec tout type de données disponible.

Procédures pour écrire sur un emplacement du registre spécifique

Après avoir déterminé les fonctions qu'il vous faudra utiliser pour votre projet, copiez les déclarations appropriées qui se trouvent dans le code en bas de cet article dans un module Visual Basic. Les deux procédures Visual Basic incluses (SetValueEx et QueryValueEx) sont des wrappers pour les fonctions API RegSetValueEx et RegQueryValueEx, qui simplifient grandement leur utilisation. Les notes ci-dessous utilisent ces fonctions Visual Basic, mais vous pouvez si vous le souhaitez effectuer des appels directs à l'API.

Création/modification de clés et de valeurs :

Une fois les déclarations et les procédures disponibles, vous pouvez créer et ouvrir des clés, et ajouter, modifier et lire des valeurs. Les trois sections suivantes expliquent comment créer une clé, définir ou modifier une valeur et interroger une valeur.

Création d'une nouvelle clé :

La création d'une nouvelle clé est très simple et implique l'utilisation de la procédure suivante. CreateNewKey prend le nom de la clé à créer et la constante représentant la clé prédéfinie sous laquelle créer la clé. L'appel à RegCreateKeyEx ne tire pas parti des mécanismes de sécurité disponibles, mais peut être modifié à cette fin. Une discussion de la sécurité du registre est au-delà de la portée de cet article.
   Private Sub CreateNewKey (sNewKeyName As String, lPredefinedKey As Long)       Dim hNewKey As Long         'descripteur de la nouvelle clé       Dim lRetVal As Long         'résultat de la fonction RegCreateKeyEx       lRetVal = RegCreateKeyEx(lPredefinedKey, sNewKeyName, 0&, _                 vbNullString, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, _                 0&, hNewKey, lRetVal)       RegCloseKey (hNewKey)   End Sub

Avec cette procédure, l'appel :
   CreateNewKey "TestKey", HKEY_LOCAL_MACHINE

créera une clé nommée TestKey immédiatement sous HKEY_LOCAL_MACHINE.

Un appel à CreateNewKey comme suit :
      CreateNewKey "TestKey\SubKey1\SubKey2", HKEY_LOCAL_MACHINE

créera trois clés imbriquées commençant par TestKey immédiatement sous HKEY_CURRENT_USER, SubKey1 subordonnée à TestKey, et SubKey3 sous SubKey2.

Définition/modification d'une valeur :

La création et la définition de la valeur d'une clé spécifiée peuvent être effectuées à l'aide de la brève procédure ci-dessous. SetKeyValue prend la clé à laquelle la valeur sera associée, le nom de la valeur, sa définition et son type (la fonction SetValueEx ne prend en charge que REG_SZ et REG_DWORD, mais ceci peut être modifié si souhaité). La spécification d'une nouvelle valeur pour un sValueName existant modifiera la définition actuelle de cette valeur.
   Private Sub SetKeyValue (sKeyName As String, sValueName As String, _   vValueSetting As Variant, lValueType As Long)       Dim lRetVal As Long         'résultat de la fonction SetValueEx       Dim hKey As Long         'handle de la clé ouverte       'ouverture de la clé spécifiée       lRetVal = RegOpenKeyEx(HKEY_CURRENT_USER, sKeyName, 0, _                                 KEY_SET_VALUE, hKey)       lRetVal = SetValueEx(hKey, sValueName, lValueType, vValueSetting)       RegCloseKey (hKey)   End Sub

L'appel :
   SetKeyValue "TestKey\SubKey1", "StringValue", "Hello", REG_SZ

créera une valeur de type REG_SZ nommée "StringValue" avec comme définition "Hello". Cette valeur sera associée à la clé SubKey1 de "TestKey".

Dans le cas présent, "TestKey" est une sous-clé de HKEY_CURRENT_USER, mais ceci peut être modifié en changeant l'appel à RegOpenKeyEx. Cet appel échouera si "TestKey\SubKey1" n'existe pas. Pour éviter ce problème, utilisez un appel à RegCreateKeyEx au lieu d'un appel à RegOpenKeyEx. RegCreateKeyEx ouvrira une clé spécifiée si elle existe déjà.

Interrogation d'une valeur :

La procédure suivante peut être utilisée pour vérifier la définition d'une valeur existante. QueryValue prend le nom de la clé et celui de la valeur associée à cette clé, et affiche un message contenant la valeur correspondante. Elle utilise un appel à la fonction wrapper QueryValueEx définie ci-dessous, qui ne prend en charge que les types REG_SZ et REG_DWORD.
   Private Sub QueryValue (sKeyName As String, sValueName As String)       Dim lRetVal As Long         'résultat des fonctions API       Dim hKey As Long         'handle de la clé ouverte       Dim vValue As Variant      'définition de la valeur interrogée       lRetVal = RegOpenKeyEx(HKEY_CURRENT_USER, sKeyName, 0, _   KEY_QUERY_VALUE, hKey)       lRetVal = QueryValueEx(hKey, sValueName, vValue)       MsgBox vValue       RegCloseKey (hKey)   End Sub

Avec cette procédure, l'appel :
   QueryValue "TestKey\SubKey1", "StringValue"

affichera un message avec la définition actuelle de la valeur "StringValue", et présume que "StringValue" existe dans la clé "TestKey\SubKey1".

Si la valeur interrogée n'existe pas, alors QueryValue renverra un code d'erreur 2 - 'ERROR_BADKEY'.

Remarques supplémentaires :

Les exemples ci-dessus utilisent exclusivement les versions 32 bits étendues des fonctions du registre. Ces fonctions permettent d'associer plus d'une valeur à chaque clé. Comme discuté plus haut, les fonctions RegSetValue et RegQueryValue 16 bits agissent sur une seule valeur associée à la clé actuelle (qui est toujours du type REG_SZ). Ces fonctions apparaissent dans l'Éditeur du registre 32 bits avec comme nom <SANS NOM>. Pour définir, modifier ou interroger cette valeur associée spéciale, vous devez utiliser les fonctions du registre 16 bits. La lecture et l'écriture à partir d'un registre dans un environnement 16 bits sont beaucoup plus simples que dans un environnement 32 bits. La procédure de base est la même : ouverture d'une clé et obtention d'un descripteur, puis appel de la fonction de modification avec ce descripteur. Par contre, aucune considération ne doit être apportée aux valeurs multiples associées ou aux différents types de données de valeur. Une application 16 bits peut créer et modifier des clés et des valeurs avec les déclarations des fonctions RegCreateKey, RegOpenKey, RegQueryValue, RegSetValue et RegCloseKey.

Dans certains cas, il n'est pas nécessaire d'associer de valeur à une clé. Une application souhaitera simplement savoir si une certaine clé ou valeur existe, sans se soucier de la nature des valeurs de la clé. Dans une situation comme celle-ci, les fonctions RegEnumKey, RegEnumKeyEx et RegEnumValue peuvent être utilisées pour déterminer si une certaine clé ou valeur existe. Pour plus d'informations sur ces fonctions, consultez la Visionneuse de texte API et/ou la référence de l'API Windows.

Fonction API et déclaration de constante

   Option Explicit   Public Const REG_SZ As Long = 1   Public Const REG_DWORD As Long = 4   Public Const HKEY_CLASSES_ROOT = &H80000000   Public Const HKEY_CURRENT_USER = &H80000001   Public Const HKEY_LOCAL_MACHINE = &H80000002   Public Const HKEY_USERS = &H80000003   Public Const ERROR_NONE = 0   Public Const ERROR_BADDB = 1   Public Const ERROR_BADKEY = 2   Public Const ERROR_CANTOPEN = 3   Public Const ERROR_CANTREAD = 4   Public Const ERROR_CANTWRITE = 5   Public Const ERROR_OUTOFMEMORY = 6   Public Const ERROR_ARENA_TRASHED = 7   Public Const ERROR_ACCESS_DENIED = 8   Public Const ERROR_INVALID_PARAMETERS = 87   Public Const ERROR_NO_MORE_ITEMS = 259   Public Const KEY_QUERY_VALUE = &H1   Public Const KEY_SET_VALUE = &H2   Public Const KEY_ALL_ACCESS = &H3F   Public Const REG_OPTION_NON_VOLATILE = 0   Declare Function RegCloseKey Lib "advapi32.dll" _   (ByVal hKey As Long) As Long   Declare Function RegCreateKeyEx Lib "advapi32.dll" Alias _   "RegCreateKeyExA" (ByVal hKey As Long, ByVal lpSubKey As String, _   ByVal Reserved As Long, ByVal lpClass As String, ByVal dwOptions _   As Long, ByVal samDesired As Long, ByVal lpSecurityAttributes _   As Long, phkResult As Long, lpdwDisposition As Long) As Long   Declare Function RegOpenKeyEx Lib "advapi32.dll" Alias _   "RegOpenKeyExA" (ByVal hKey As Long, ByVal lpSubKey As String, _   ByVal ulOptions As Long, ByVal samDesired As Long, phkResult As _   Long) As Long   Declare Function RegQueryValueExString Lib "advapi32.dll" Alias _   "RegQueryValueExA" (ByVal hKey As Long, ByVal lpValueName As _   String, ByVal lpReserved As Long, lpType As Long, ByVal lpData _   As String, lpcbData As Long) As Long   Declare Function RegQueryValueExLong Lib "advapi32.dll" Alias _   "RegQueryValueExA" (ByVal hKey As Long, ByVal lpValueName As _   String, ByVal lpReserved As Long, lpType As Long, lpData As _   Long, lpcbData As Long) As Long   Declare Function RegQueryValueExNULL Lib "advapi32.dll" Alias _   "RegQueryValueExA" (ByVal hKey As Long, ByVal lpValueName As _   String, ByVal lpReserved As Long, lpType As Long, ByVal lpData _   As Long, lpcbData As Long) As Long   Declare Function RegSetValueExString Lib "advapi32.dll" Alias _   "RegSetValueExA" (ByVal hKey As Long, ByVal lpValueName As String, _   ByVal Reserved As Long, ByVal dwType As Long, ByVal lpValue As _   String, ByVal cbData As Long) As Long   Declare Function RegSetValueExLong Lib "advapi32.dll" Alias _   "RegSetValueExA" (ByVal hKey As Long, ByVal lpValueName As String, _   ByVal Reserved As Long, ByVal dwType As Long, lpValue As Long, _   ByVal cbData As Long) As Long

Fonctions wrapper SetValueEx et QueryValueEx :
   Public Function SetValueEx(ByVal hKey As Long, sValueName As String, _   lType As Long, vValue As Variant) As Long       Dim lValue As Long       Dim sValue As String       Select Case lType           Case REG_SZ               sValue = vValue & Chr$(0)               SetValueEx = RegSetValueExString(hKey, sValueName, 0&, _                                              lType, sValue, Len(sValue))           Case REG_DWORD               lValue = vValue               SetValueEx = RegSetValueExLong(hKey, sValueName, 0&, _   lType, lValue, 4)           End Select   End Function   Function QueryValueEx(ByVal lhKey As Long, ByVal szValueName As _   String, vValue As Variant) As Long       Dim cch As Long       Dim lrc As Long       Dim lType As Long       Dim lValue As Long       Dim sValue As String       On Error GoTo QueryValueExError       ' Déterminez la taille et le type de données à lire       lrc = RegQueryValueExNULL(lhKey, szValueName, 0&, lType, 0&, cch)       If lrc <> ERROR_NONE Then Error 5       Select Case lType           ' Pour les chaînes           Case REG_SZ:               sValue = String(cch, 0)   lrc = RegQueryValueExString(lhKey, szValueName, 0&, lType, _   sValue, cch)               If lrc = ERROR_NONE Then                   vValue = Left$(sValue, cch-1)               Else                   vValue = Empty               End If           ' Pour DWORDS           Case REG_DWORD:   lrc = RegQueryValueExLong(lhKey, szValueName, 0&, lType, _   lValue, cch)               If lrc = ERROR_NONE Then vValue = lValue           Case Else               'all other data types not supported               lrc = -1       End Select   QueryValueExExit:       QueryValueEx = lrc       Exit Function   QueryValueExError:       Resume QueryValueExExit   End Function
Références
Programmation de l'interface utilisateur de Windows 95, Chapitre 10 - "Utilisation du registre"

Pour des références sur les fonctions : Tout guide API Win16 ou Win32.
registry
Propriétés

ID d'article : 145679 - Dernière mise à jour : 08/18/2003 21:21:00 - Révision : 1.3

  • Microsoft Visual Basic 5.0 Édition professionnelle
  • Microsoft Visual Basic 6.0 Édition professionnelle
  • Microsoft Visual Basic 5.0 Édition Entreprise
  • Microsoft Visual Basic 6.0 Édition Entreprise
  • Microsoft Visual Basic 4.0 Édition Standard
  • Microsoft Visual Basic 4.0 Édition professionnelle
  • Microsoft Visual Basic 4.0 Édition professionnelle
  • Microsoft Visual Basic 4.0 16-bit Enterprise Edition
  • Microsoft Visual Basic 4.0 32-Bit Enterprise Edition
  • Microsoft Visual Basic for Applications 5.0
  • Microsoft Visual Basic pour Applications 6.0
  • kbhowto kbvb500 kbvbp kbtophit kbvbp400 kbvbp500 kbgrpdsvbdb kbvbp600 kbcode kbnokeyword kbvba KB145679
Commentaires