FAQ DelphiConsultez toutes les FAQ

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 figurent en haut de la hiérarchie du Registre.

Chaque nœud dans l'arbre s'appelle une clé.
Chaque clé peut contenir des sous-clés et des rubriques valuées appelés valeurs.
Une clé peut avoir n'importe quel nombre de valeurs, et les valeurs peuvent être de n'importe quelle 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 un 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 en ce qui concerne la clé qui est immédiatement au-dessus de lui dans la hiérarchie.
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 racine 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 sont stockées 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.

À noter que les noms de clés et de types prédéfinis dépendent de la version de l'OS.
Certaine version de Delphi ne gère nativement qu'un sous ensemble de types prédéfinis.
Reportez-vous à l'aide en ligne du programme Regedit ou au SDK Windows
Pour avoir accès à ces clés, vous devez ajouter l'unité Windows dans vos uses.

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 de l'inclure dans la clause uses avant tout manipulation du registre.

L'accès à la base de registre se fait en plusieurs étapes.

1. Création d'un objet Registry :
   Il faut avant toute chose créer l'objet qui va permettre l'accès à la base de registre.
   Cela se fait grâce au constructeur de la classe TRegistry.Create. N'oubliez pas de déclarer cette objet.
   

   Code delphi :

   Sélectionner tout

   1
   2
   3
   4
   5
   var  
     Registre: TRegistry;  
   begin  
     Registre := TRegistry.Create;  
     ...

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
   

   Code delphi :

   Sélectionner tout

   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. L'objet Registre possède une méthode qui permet de le faire : CloseKey;
   

   Code delphi :

   Sélectionner tout

   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 Registre créé au début du traitement.
   

   Code delphi :

   Sélectionner tout

   Registre.Free;

   La méthode TRegistry.Destroy appel la méthode CloseKey avant de détruire l'objet. La suite d'instruction ci-dessous est donc redondante :
   

   Code delphi :

   Sélectionner tout

   1
   2
   Registre.CloseKey;  
   Registre.Free;

1
2
3
4
5
6
7
With TRegistry.Create Do 
Try 
  RootKey := HKEY_CLASSES_ROOT; 
  // Traitement... 
Finally 
  Free; 
End;

Quelques méthodes de TRegistry n'opère 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(const Key: string): Boolean.

1
2
3
if Registre.KeyExists('nom_de_la_clé')  
  then 
   ... // Nom absolu

Quelques méthodes de TRegistry n'opère que sur des valeurs de clé existante, dans ces cas là on testera préalablement leur existence en utilisant la méthode ValueExists(const Name: string): Boolean.

1
2
3
if Registre.ValueExists('nom_de_la_valeur')  
  then 
   ... // Nom absolu

Lorsqu'on exécute un traitement itératif sur un sous ensemble de clé 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: Boolean;.

1
2
3
if Registre.HasSubKeys   
  then 
   ...

Pour créer une nouvelle clé au registre on utilise la méthode CreateKey(const Key: String): Boolean; de l'objet Registre.
Le nom de la clé à créer peut être un nom absolu ou un nom relatif.

Registre.CreateKey('HKEY_CURRENT_USER\Software\Essai'); // Nom absolu

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(const Key: String; CanCreate: Boolean): Boolean; de l'objet Registre.

Registre.OpenKey('nom_de_la_clé', True);

myString := Registre.ReadString('nom_de_la_valeur');

Registre.WriteString('nom_de_la_valeur', 'valeur');

Registre.DeleteValue('nom_de_la_valeur');

Lorsqu'on envisage d'effectuer un traitement itératif sur un ensemble de clés, on utilise la méthode GetKeyNames(Strings: TStrings); Elle permet de récupérer dans une liste (TSrings) l'ensemble des noms de toutes les sous-clés de la clé en cours.

Registre.GetKeyNames(MaListeDeCle);

Lorsqu'on envisage d'effectuer un traitement itératif sur l'ensemble des valeurs d'une clé, on utilise la méthode GetValueNames(Strings: TStrings);. Elle permet de récupérer dans une liste (TSrings) l'ensemble des valeurs de la clé en cours.

Registre.GetValueNames(MaListeDeValeur);

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(const Key: String): Boolean; de l'objet Registre.

Registre.DeleteKey('nom_de_la_clé');

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(const UNCName: String): Boolean;.

Le paramètre "UNCName" contient un nom de machine au format UNC. le format UNC étant égale à '\\<serveur>\<nom_partage>'

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
Procedure LitClesDistante(ServerName:String; ListeSousCle:TStringList;); 
Const 
  CleMachineDistante ='SOFTWARE\Microsoft\Windows\CurrentVersion'; 
  CleRecherchee      ='App Paths'; 
Var 
  
  RegistreMachineDistante: TRegistry; 
begin 
  
  ListeSousCle.Clear; 
  
 RegistreMachineDistante:=TRegistry.Create; 
  
 Try 
  
   // Pour les accès distant la propriété RootKey est égale 
    // soit à HKEY_USERS soit à HKEY_LOCAL_MACHINE. 
  
   RegistreMachineDistante.RootKey:=HKEY_LOCAL_MACHINE; 
    // Connexion sur une machine distante 
    if not RegistreMachineDistante.RegistryConnect('\\'+ServerName) then 
  
   begin 
  
     // Vérifier la configuration réseaux 
      // ou les permissions d'accès. 
      MessageDlg('Ne peut se connecter sur :'#13#10+ServerName, mtWarning,[mbOk], 0); 
      Exit; 
    end; 
    if RegistreMachineDistante.OpenKeyReadOnly('\'+CleMachineDistante+'\'+CleRecherchee)then 
  
     RegistreMachineDistante.GetKeyNames(ListeSousCle); {Liste de sous clés} 
    else 
      MessageDlg('Erreur clé absente:'#13#10+CleRecherchee, mtWarning,[mbOk], 0); 
  Finally 
    RegistreMachineDistante.Free;  // Ferme la clé et libère la mémoire allouée. 
  End; 
end;

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ée 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.

Il n'existe pas de fonction toute prête permettant de réaliser cette opération. Vous pouvez toutefois utiliser ou vous inspirer d'un composant décrit dans l'article ci-dessous.

Les associations d'extension sont décrites dans la Base de Registres, sous la ruche HKEY_CLASSES_ROOT

Une première clé doit porter le nom de l'extension concernée, par exemple :

.bmp

Paint.Picture

Paint.Picture

Image bitmap

shimgvw.dll,1

C:\Windows\Notepad.exe,1

open;edit;print.

open

&Ouvrir

"C:\Windows\NotePad.exe" "%1"

rundll32.exe C:\WINDOWS\System32\shimgvw.dll,ImageView_Fullscreen "%1"

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
uses Forms, Registry; 
... 
procedure RegisterExt(Ext, IDTypeFichier, NomTypeFichier : string); 
begin 
  with TRegistry.Create do 
  try 
    RootKey := HKEY_CLASSES_ROOT; 
  
    // Affectation à l'extension Ext le type IDTypeFichier 
    OpenKey('\.'+Ext, True); 
    WriteString('', IDTypeFichier); 
    CloseKey; 
  
    // Spécification du nom du type de fichier 
    OpenKey('\'+IDTypeFichier); 
    WriteString('', NomTypeFichier); 
    CloseKey; 
  
    // Spécification de l'icône assossiée aus fichiers de ce type 
    OpenKey('\'+IDTypeFichier+'\DefaultIcon', True); 
    WriteString('', Application.ExeName+',0'); 
    CloseKey; 
  
    // Spécification de la liste des commandes 
    OpenKey('\'+IDTypeFichier+'\shell', True); 
    WriteString('open'); 
    CloseKey; 
  
    // Spécification du nom de la commande open 
    OpenKey('\'+IDTypeFichier+'\shell\open', True); 
    WriteString('', '&Ouvrir'); 
    CloseKey; 
  
    // Spécification de la commande open 
    OpenKey('\'+IDTypeFichier+'\shell\open\command', True); 
    WriteString('', '"'+Application.ExeName+'" "%1"'); 
    CloseKey; 
  finally 
    Free; 
  end; 
end;

Il est parfois nécessaire de connaître l'application associée à une extension, ainsi que son chemin d'accès. Cela peut être retrouvé grâce à la base de registre :

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
function ExtToApp(Ext: string): string;  
var Command, s: string; i: integer;  
begin  
  Result := ''; // = pas trouvé  
  with TRegistry.Create do  
  try  
    RootKey := HKEY_CLASSES_ROOT;  
    if OpenKey('\.' + Ext, False) then  
      if OpenKey('\' + ReadString('') + '\shell\', False) then  
      begin  
        Command := ReadString('');  
        if Command = '' then Command := 'open' else  
          if Pos(',', Command) > 0 then  
            Command := LeftStr(Command, Pos(',', Command) - 1);  
        if OpenKey(Command + '\command\', false) then  
        begin  
          Result := Trim(ReadString(''));  
          if Result <> '' then  
            if Result[1] = '"' then  
            begin  
              Delete(Result, 1, 1);  
              Result := LeftStr(Result, Pos('"', Result) - 1);  
            end else  
            begin  
              s := Trim(ExtractFileExt(Result));  
              if pos(' ', s) > 0 then  
              begin  
                i := pos(s, Result);  
                Result := LeftStr(Result, i + Pos(' ', s) - 1);  
              end;  
            end;  
        end;  
      end;  
  finally  
    Free;  
  end;  
end;

ShowMessage(ExtToApp('pas'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function AppPath(Fichier: string): string;  
var  
  ExeName: PChar;  
begin  
  Result := '';  
  
  If not FileExists(Fichier) then  
    Exit;  
  
  GetMem(ExeName, MAX_PATH);  
  
  if FindExecutable(pChar(Fichier), nil, ExeName) > 32 then  
    Result := StrPas(ExeName);  
  
  FreeMem(ExeName);  
end;

ShowMessage(AppPath('C:\Unit1.pas'));

Vous devez parcourir la clé de registre \SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall pour retrouver la liste des applications installées.

Créez une nouvelle application GUI,
Ajoutez l'unité Registry dans la clause Uses,
Placez sur votre forme les composants suivants :

• un TListBox, nommé ListBox1,
• un TButton, nommé Button1,
  

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
procedure TForm1.Button1Click(Sender: TObject); 
const 
  REGKEYAPPS = '\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall'; 
var 
  reg    : TRegistry; 
  List1  : TStringList; 
  List2  : TStringList; 
  i, n   : integer; 
  
begin 
  reg    := TRegistry.Create; 
  List1  := TStringList.Create; 
  List2  := TStringList.Create; 
  
  {Charge toutes les sous-clés} 
  with reg do 
  begin 
    RootKey := HKEY_LOCAL_MACHINE; 
    OpenKey(REGKEYAPPS, false); 
    GetKeyNames(List1); 
  end; 
  
  {Charge toutes les valeurs} 
   for i := 0 to List1.Count -1 do 
   begin 
     reg.OpenKeyReadOnly(REGKEYAPPS + '\' + List1.Strings[i]); 
     reg.GetValueNames(list2); 
  
    {On affiche seulement celles de nom 'DisplayName'} 
    n := List2.IndexOf('DisplayName'); 
  
    if (n <> -1) and (List2.IndexOf('UninstallString') <> -1) then 
    begin 
      ListBox1.Items.Add((reg.ReadString(List2.Strings[n]))); 
    end; 
  end; 
  
  {Libération des ressources} 
  List1.Free; 
  List2.Free; 
  reg.CloseKey; 
  reg.Destroy; 
end;

Le code suivant vous permet de sauvegarder la base de registre. En paramètre, vous devez spécifier le "timeout" c'est à dire le temps après lequel l'opération de sauvegarde sera considérée comme un échec et annulée ainsi que le nom du fichier de sauvegarde.

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.SaveRegister(iTimeOutMs: DWORD; sFileName : SHortString); 
// iTimeOutMs est le TimeOut définit en MilliSecondes 
// sFileName est le chemin et le nom de fichier à créer  
(ex:'C:\TestSave.reg') 
Var 
  Ticks: DWord; 
  StartInfo: TStartupInfo; 
  ProcessInfo: TProcessInformation; 
  Fin: Boolean; 
Begin 
  FillChar(StartInfo, SizeOf(StartInfo), #0); 
  StartInfo.cb := SizeOf(StartInfo); 
  
  If CreateProcess(Nil, PChar('regedit.exe /se ' +sFileName), 
    Nil, Nil, False, 0, Nil, Nil, StartInfo, ProcessInfo) Then 
  Begin 
    ShowMessage('Sauvegarde en cours... '); 
    Ticks := GetTickCount; 
    Fin := False; 
  
    Repeat 
      Case WaitForSingleObject(ProcessInfo.hProcess, 200) Of 
        WAIT_OBJECT_0: Fin := True; 
      End; 
  
      Application.ProcessMessages; //pour éviter que l'application ne se "bloque" 
      Sleep(250); 
    Until (Fin) Or (GetTickCount - Ticks > iTimeOutMs); 
  
    If (Fin = False) Then 
      ShowMessage('TimeOut ! La sauvegarde ne s''est pas terminée  
correctement... ') 
    Else 
      ShowMessage('La sauvegarde est terminée. ') 
  End else 
    ShowMessage('Erreur du lancement de la sauvegarde ! '); 
end;