IdentifiantMot de passe
Mot de passe oublié ?Je m'inscris ! (gratuit)
logo
Sommaire > Système > Base de Registre
        Comment est structurée la base de registre ?
        Comment accéder à la base de registre de Windows ?
        Comment tester l'existence d'une clé ?
        Comment tester l'existence d'une valeur d'une clé ?
        Comment tester l'existence d'une sous-clé ?
        Comment créer une clé ?
        Comment ouvrir une clé et lire/modifier/supprimer une valeur ?
        Comment lire les noms de toutes les sous-clés de la clé en cours ?
        Comment lire toutes les valeurs de la clé en cours ?
        Comment supprimer une clé ?
        Comment opérer sur une base de registre d'une machine distante ?
        Comment modifier les droits d'accès d'un objet de type TRegistry ?



Comment est structurée la base de registre ?
Créé le 31/01/2005[haut]
auteur : Laurent Dardenne
La base de registre stocke ses données dans un arbre hiérarchiquement structuré. La partie du registre qui apparaît en tant que fichier sur votre disque dur s'appelle une ruche. Le sous-arbre du registre est divisé en ruches (en raison de leur ressemblance avec la structure cellulaire d'une ruche d'abeilles). Une ruche correspond à un ensemble discret de clés, de sous-clés et de valeurs, qui figure en haut de la hiérarchie du Registre.

Chaque noeud dans l'arbre s'appelle une clé.
Chaque clé peut contenir des sous-clés et des rubriques valuées appelées valeurs. Une clé peut avoir n'importe quel nombre de valeurs, et les valeurs peuvent être de n'importe quel type prédéfini.
Chaque clé possède un nom se composant d'un ou plusieurs caractères imprimables c'est-à-dire, s'étendant des valeurs ASCII 32 à 127.
Les noms principaux ne peuvent pas inclure d'espace, d'antislash (\), ou de caractère de remplacement (* ou ?).
Les noms principaux commençant par un point (.) sont réservés.
Le nom de chaque sous-clé est unique dans le contexte de sa clé parente.
Les noms de clé n'utilisent pas d'autres langues que l'US ; les valeurs peuvent par contre utiliser d'autres langues.

Notes:
  • Une clé absolue commence par une barre oblique inverse (\) et est sous-clé de la clé racine.
  • Une clé relative est sous-clé de la clé en cours.
  • Une clé non-volatile est stockée dans un fichier et est préservée lorsque le système redémarre ( NT ).
  • Une clé volatile est stockée en mémoire et n'est pas préservée lorsque le système redémarre ( NT ).

Clés racines prédéfinies :
HKEY_CURRENT_USER
Correspond à la racine contenant les informations de configuration de l'utilisateur connecté. Les paramètres utilisateur des dossiers, des couleurs d'écran et du Panneau de configuration sont stockés ici. Ces informations constituent un profil utilisateur.

HKEY_USERS
Correspond à la racine de tous les profils d'utilisateurs de l'ordinateur. HKEY_CURRENT_USER est une sous-clé de HKEY_USERS.

HKEY_LOCAL_MACHINE
Contient les informations de configuration spécifiques à l'ordinateur (pour tous les utilisateurs).

HKEY_CLASSES_ROOT
Sous-clé de HKEY_LOCAL_MACHINE\Software. Les informations stockées ici garantissent l'ouverture du programme voulu lorsque vous ouvrez un fichier depuis l'Explorateur Windows.

HKEY_CURRENT_CONFIG
Contient des informations sur le profil matériel utilisé par l'ordinateur local au démarrage.

Types de données prédéfinis :
REG_BINARY
Données binaires brutes. La plupart des informations concernant les composants matériels est stockée sous forme de données binaires.

REG_DWORD
Données représentées par un nombre de 4 octets. Beaucoup de paramètres concernant les pilotes de périphériques et les services sont de ce type.

REG_EXPAND_SZ
Chaîne de longueur variable. Ce type de données comprend les variables qui sont résolues lorsqu'un programme ou un service les utilise.

REG_MULTI_SZ
Chaîne multiple. Les valeurs qui contiennent des listes ou plusieurs valeurs sous une forme lisible par l'homme sont généralement de ce type. Les différentes valeurs sont séparées par un espace, une virgule ou un autre signe.

REG_SZ
Chaîne de texte de longueur fixe.

REG_FULL_RESOURCE_DESCRIPTOR
Série de tableaux imbriqués destinés à stocker une liste de ressources pour un composant matériel ou un pilote.

A noter que les noms de clés et de type prédéfinis dépendent de la version de l'OS. Certaines versions de C++ Builder ne gèrent nativement qu'un sous ensemble de type prédéfini. Reportez-vous à l'aide en ligne du programme Regedit ou au SDK Windows.

lien : en SDK - Registry Functions

Comment accéder à la base de registre de Windows ?
Créé le 31/01/2005[haut]
auteurs : Laurent Dardenne, Ricky81
Tous les accès à la base de registre sont encapsulés dans une classe : TRegistry. Cette classe est définie dans l'unité Registry, c'est pourquoi il est indispensable d'inclure registry.hpp avant toute manipulation du registre.

#include <registry.hpp>
L'accès à la base de registre se fait en plusieurs étapes.

1. Création d'un objet Registry :
Il faut commencer par initialiser un objet pour manipuler la base de registre :

TRegistry *registre = new TRegistry();
Il est possible de passer au constructeur un long pour initialiser la propriété Access (niveau d'accès à utiliser).

2. Sélection de la clé racine :
Avant d'accéder à la clé, il faut en spécifier la clé racine dans le registre. Cela se fait en affectant le nom de la clé racine à la propriété RootKey de l'objet registre précédemment crée. Ce nom de clé est un nom prédéfini, par exemple HKEY_CURRENT_USER (voyez dans Winreg.h pour les constantes disponibles).

registre->RootKey = HKEY_CLASSES_ROOT;
Si par la suite on souhaite accéder à une autre clé racine on doit fermer la clé racine courante puis ouvrir avec la nouvelle clé racine.

3. Fermeture de la clé racine :
Avant de terminer les opérations sur la base de registre ou de modifier la propriété RootKey, il est important de valider les modifications apportées par la fermeture la clé en cours. Le type TRegistry possède une méthode qui permet de le faire : CloseKey.

registre->CloseKey();
Le comportement de cette méthode dépend de la propriété LazyWrite. Il est recommandé de ne pas maintenir les clés ouvertes plus longtemps que nécessaire.

4. Destruction de l'objet Registre et libération des ressources :
Afin de libérer la mémoire, il est nécessaire de détruire l'objet créé au début du traitement.

delete registre;
Le destructeur appelle la méthode CloseKey avant de détruire l'objet. La suite d'instructions qui suit est donc redondante :

registre->CloseKey();
delete regisre;
Note : Il est recommandé d'utiliser la gestion d'exception de type try...catch et/ou try...__finally afin de gérer tous les cas d'erreurs et ainsi libérer la mémoire allouée.

TRegistry *registre = new TRegistry();
try
{
   registre->RootKey = HKEY_CLASSES_ROOT;
   // Traitement...
}
__finally
{
   delete registre;
}
lien : faq Comment modifier les droits d'accès d'un objet de type TRegistry ?

Comment tester l'existence d'une clé ?
Créé le 31/01/2005[haut]
auteur : Laurent Dardenne
Quelques méthodes de TRegistry n'opèrent que sur des clés existantes, dans ces cas-là on testera préalablement l'existence de la clé en utilisant la méthode KeyExists.

if registre->KeyExists("nom_de_la_clé")
{
  // ...
lien : faq Comment tester l'existence d'une valeur d'une clé ?
lien : faq Comment tester l'existence d'une sous-clé ?

Comment tester l'existence d'une valeur d'une clé ?
Créé le 31/01/2005[haut]
auteur : Laurent Dardenne
Quelques méthodes de TRegistry n'opèrent que sur des valeurs de clé existante, dans ces cas-là on testera préalablement leur existence en utilisant la méthode ValueExists.

if registre->ValueExists("nom_de_la_valeur")
{
  // ...
lien : faq Comment tester l'existence d'une clé ?
lien : faq Comment tester l'existence d'une sous-clé ?

Comment tester l'existence d'une sous-clé ?
Créé le 31/01/2005[haut]
auteur : Laurent Dardenne
Lorsqu'on exécute un traitement itératif sur un sous-ensemble de clés il est parfois nécessaire de savoir si la clé en cours possède des sous-clés. Dans ces cas-là on utilisera la méthode HasSubKeys.

if registre->HasSubKeys()
{
  // ...
Cette méthode est généralement couplée avec la méthode GetKeyNames.

lien : faq Comment tester l'existence d'une valeur d'une clé ?
lien : faq Comment tester l'existence d'une clé ?

Comment créer une clé ?
Créé le 31/01/2005[haut]
auteur : Ricky81
Pour créer une nouvelle clé on utilise la méthode CreateKey. Le nom de la clé à créer peut être absolu ou relatif.

TRegistry *registre = new TRegistry();
registre->RootKey = HKEY_CURRENT_USER;
if(registre->CreateKey("\\Software\\Essai")) // Nom absolu
{
  ...
Une clé en absolu l'est par rapport à la clé racine, la chaîne passée commence nécessairement par \ (doublé ici car \ est le caractère d'échappement). Ici nous créons la clé HKEY_CURRENT_USER\Software\Essai.

TRegistry *registre = new TRegistry();
registre->RootKey = HKEY_CURRENT_USER;
if(registre->OpenKeyReadOnly("Software"))
{
   if(registre->CreateKey("Test")) // Nom relatif
   {
    ...
Une clé en relatif l'est par rapport à la clé courante. Ici nous nous sommes placés sur la clé HKEY_CURRENT_USER\Software et créons donc la clé HKEY_CURRENT_USER\Software\Test.


Comment ouvrir une clé et lire/modifier/supprimer une valeur ?
Créé le 31/01/2005[haut]
auteur : Laurent Dardenne
Pour accéder à la valeur d'un nom de clé, il faut ouvrir la clé qui la contient. On utilise pour cela la méthode OpenKey de TRegistry :

bool __fastcall OpenKey(const AnsiString Key, bool CanCreate);
Exemple :

registre->OpenKey("nom_de_la_clé", true);
Notez ici que le paramètre CanCreate a pour valeur true. Cela permet au cas où la clé n'existerait pas, de forcer sa création puis son ouverture. Il s'agit en quelque sorte d'une combinaison d'appel de CreateKey puis d'OpenKey.

Il est à présent possible de lire, écrire ou supprimer une valeur d'une clé.
Pour lire, écrire ou supprimer une valeur chaîne dans la clé, on utilisera les méthodes ReadString, WriteString ou DeleteString de TRegistry.

Pour la lecture :

maChaine = registre->ReadString("nom_de_la_valeur");
Pour l'écriture :

registre->WriteString("nom_de_la_valeur", "valeur");
On utilisera cette méthode pour modifier une clé existante.

Pour la suppression :

if(registre->DeleteValue("nom_de_la_valeur");
{
  ...
Note : Ici nous avons traité les exemples de la lecture, de l'écriture et de la suppression d'une valeur d'une clé de type chaîne de caractères. Il existe des méthodes spécifiques pour manipuler les autres types de données. Pour les connaître reportez-vous à l'aide.


Comment lire les noms de toutes les sous-clés de la clé en cours ?
Créé le 31/01/2005[haut]
auteur : Ricky81
Lorsqu'on envisage d'effectuer un traitement itératif sur un ensemble de clés, on utilise la méthode GetKeyNames. Elle permet de récupérer une liste de l'ensemble des noms des sous-clés de la clé en cours en initialisant un objet d'un type descendant de TStrings.

TRegistry *registre = new TRegistry();
TStringList *mesCles = new TStringList();

// la clé racine par défaut est HKEY_CURRENT_USER
registre->OpenKeyReadOnly("Software"); // clé courante
registre->GetKeyNames(mesCles);
ShowMessage(mesCles->Count); // affiche le nombre de sous-clés

delete registre;
delete mesCles;
lien : faq Comment lire toutes les valeurs de la clé en cours ?

Comment lire toutes les valeurs de la clé en cours ?
Créé le 31/01/2005[haut]
auteur : Ricky81
Lorsqu'on envisage d'effectuer un traitement itératif sur l'ensemble des valeurs d'une clé, on utilise la méthode GetValueNames. Elle permet de récupérer une liste de l'ensemble des valeurs de la clé en cours en initialisant un objet d'un type descendant de TStrings.

TRegistry *registre = new TRegistry();
TStringList *mesCles = new TStringList();

registre->OpenKeyReadOnly("Software\\Borland\\C++Builder\\6.0"); // clé courante
registre->GetValueNames(mesCles); // lecture des noms

// affichage d'une des valeurs
AnsiString val, res;
val = mesCles->Strings[6];
res = val + "=" + registre->ReadString(val);
ShowMessage(res); // affiche "Version=PRO"

delete registre;
delete mesCles;
lien : faq Comment lire les noms de toutes les sous-clés de la clé en cours ?

Comment supprimer une clé ?
Créé le 31/01/2005[haut]
auteur : Laurent Dardenne
On peut supprimer une clé devenue inutile : cette opération supprimera également toutes les valeurs qu'elle contient.
Ceci est le rôle de la méthode DeleteKey de TRegistry.

if(registre->DeleteKey("nom_de_la_clé"))
{
   // la clé a bien été supprimée
}
Note : Après l'avoir supprimée, il n'est pas nécessaire de fermer cette clé.
Le comportement de cette méthode diffère selon l'OS. Consultez l'aide.


Comment opérer sur une base de registre d'une machine distante ?
Créé le 31/01/2005[haut]
auteur : Laurent Dardenne
Il est parfois nécessaire de modifier des clés de registre d'une machine distante. Dans ce cas on utilise la méthode RegistryConnect.

bool __fastcall RegistryConnect(const AnsiString UNCName);
Le paramètre "UNCName" contient un nom de machine au format UNC. Le format UNC étant égal à \\<serveur>\<nom_partage> (ne pas oublier de doubler le caractère \ pour une chaîne de caractères).

void __fastcall LitClesDistantes(AnsiString serverName, TStringList* listeSousCles)
{
   AnsiString CleMachineDistante = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion";
   AnsiString CleRecherchee = "App Paths";
  
   TRegistry *registreMachineDistante = new TRegistry();
   listeSousCles->Clear();
  
   try
   {
      /* pour les accès distant la propriété RootKey est égale soit
         à HKEY_USERS soit à HKEY_LOCAL_MACHINE                  */
      registreMachineDistante->RootKey = HKEY_LOCAL_MACHINE;
      if(!registreMachineDistante->RegistryConnect("\\\\"+serverName))
      {
         // vérifier la configuration réseau ou les permissions d'accès
         ShowMessage("Impossible de se connecter.");
         return;
      }
      if(registreMachineDistante->OpenKeyReadOnly("\\"+CleMachineDistante+"\\"+CleRecherchee))
      {
         registreMachineDistante->GetKeyNames(listeSousCles); // liste des sous-clés
      }
      else
      {
         ShowMessage("Erreur, clé absente.");
      }
    }
    __finally
    {
       delete registreMachineDistante;
    }
}

Comment modifier les droits d'accès d'un objet de type TRegistry ?
Créé le 31/01/2005[haut]
auteur : Laurent Dardenne
La propriété ACCESS spécifie le niveau d'accès à utiliser lors de l'ouverture d'une clé. Le niveau d'accès autorisé dépend des permissions associées à votre compte NT.

L'accès à la base de registre d'une machine peut être limité par l'administrateur. Si vous définissez la propriété Access=KEY_ALL_ACCESS vous devez avoir le droit d'accès NT 'contrôle total' sur la clé que vous souhaitez modifier.

Sous NT/W2K et XP, vous pouvez visualiser les droits en utilisant l'outil RegEdt32.
Voir l'aide en ligne pour plus de détails.



Consultez les autres F.A.Q.

Valid XHTML 1.0 TransitionalValid CSS!

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2009 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.