FAQ DelphiConsultez toutes les FAQ

Nombre d'auteurs : 123, nombre de questions : 919, dernière mise à jour : 14 juin 2019  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums Delphi et Delphi et bases de données de www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose soient correctes. Les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous souhaitez y apporter des corrections ou la compléter, contactez un responsable (lien au bas de cette page).

Nous espérons que cette FAQ saura répondre à vos attentes. Nous vous en souhaitons une bonne lecture.

L'équipe Delphi de Developpez.com.

Commentez


SommaireSystèmeBase de registre (17)
précédent sommaire suivant
 

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.

Mis à jour le 14 janvier 2014 Laurent Dardenne

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;

Note : Il est recommandé d'utiliser la gestion d'exception de type Try...except et/ou Try...finally afin de gérer tous les cas d'erreurs et ainsi libérer la mémoire allouée.
Code delphi : Sélectionner tout
1
2
3
4
5
6
7
With TRegistry.Create Do 
Try 
  RootKey := HKEY_CLASSES_ROOT; 
  // Traitement... 
Finally 
  Free; 
End;

Mis à jour le 14 janvier 2014 Laurent Dardenne

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.

Code delphi : Sélectionner tout
1
2
3
if Registre.KeyExists('nom_de_la_clé')  
  then 
   ... // Nom absolu

Mis à jour le 14 janvier 2014 Laurent Dardenne

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.

Code delphi : Sélectionner tout
1
2
3
if Registre.ValueExists('nom_de_la_valeur')  
  then 
   ... // Nom absolu

Mis à jour le 14 janvier 2014 Laurent Dardenne

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;.

Code delphi : Sélectionner tout
1
2
3
if Registre.HasSubKeys   
  then 
   ...
cette méthode est généralement couplée avec la méthode GetKeyNames.

Mis à jour le 14 janvier 2014 Laurent Dardenne

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.

Code delphi : Sélectionner tout
Registre.CreateKey('HKEY_CURRENT_USER\Software\Essai'); // Nom absolu
CreateKey ne crée que des clés non volatiles. Pour créer des clés volatiles consulter l'API Windows. Createkey accède à la base de registre avec tout les droits (Propriété Access=KEY_ALL_ACCESS). Une fois la clé crée, elle n'est pas ouverte.

Mis à jour le 13 janvier 2014 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(const Key: String; CanCreate: Boolean): Boolean; de l'objet Registre.

Code delphi : Sélectionner tout
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 de type String dans la clé, on utilisera les méthodes ReadString(const Name: String): String;, WriteString(const Name, Value: String); ou DeleteValue(const Name: String): Boolean; de l'objet Registre.

Pour la lecture :
Code delphi : Sélectionner tout
myString := Registre.ReadString('nom_de_la_valeur');
Pour l'écriture :
Code delphi : Sélectionner tout
Registre.WriteString('nom_de_la_valeur', 'valeur');
On utilisera cette méthode pour modifier une clé existante.

Pour la suppression :
Code delphi : Sélectionner tout
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ère (String). Il existe des méthodes spécifiques pour manipuler les autres types de donnée, pour les connaître reportez-vous à l'aide de Delphi (liste des méthodes de l'objet TRegistry).

Mis à jour le 13 janvier 2014 Laurent Dardenne

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.

Code delphi : Sélectionner tout
Registre.GetKeyNames(MaListeDeCle);

Mis à jour le 13 janvier 2014 Laurent Dardenne

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.

Code delphi : Sélectionner tout
Registre.GetValueNames(MaListeDeValeur);

Mis à jour le 13 janvier 2014 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(const Key: String): Boolean; de l'objet Registre.

Code delphi : Sélectionner tout
Registre.DeleteKey('nom_de_la_clé');
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. Consulter l'aide de Delphi.

Mis à jour le 13 janvier 2014 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(const UNCName: String): Boolean;.

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

Code delphi : Sélectionner tout
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;

Mis à jour le 13 janvier 2014 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é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.

Mis à jour le 13 janvier 2014 Laurent Dardenne

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.

Mis à jour le 14 janvier 2014 Pierre Castelain

Projet RegSearch, par Pierre Castelain

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 :

Code delphi : Sélectionner tout
.bmp
La valeur par défaut de cette clé doit indiquer un identificateur de type de fichiers, par exemple :
Code delphi : Sélectionner tout
Paint.Picture
Cet identificateur peut être vu comme un pointeur sur une seconde clé qui contient réellement les informations liées à cette extension de fichier.

La deuxième clé doit porter le nom de l'identificateur de type de fichiers précédemment utilisé.
Code delphi : Sélectionner tout
Paint.Picture
Sa valeur par défaut est le nom du type de fichier, par exemple :
Code delphi : Sélectionner tout
Image bitmap
Cette deuxiéme clé doit contenir une première sous-clé nommée DefaultIcon ayant pour valeur par défaut la localisation du fichier contenant l'icône à associer. Sa syntaxe étant : Chemin_Complet_Fichier_Contenant_L_Icone,Index_De_L_Icone
Par exemple :
Code delphi : Sélectionner tout
shimgvw.dll,1
ou pour les fichiers .txt :
Code delphi : Sélectionner tout
C:\Windows\Notepad.exe,1
Cette deuxième clé doit également contenir une seconde sous-clé nommée shell. C'est sous cette clé que seront définies exactement les commandes à effectuer pour ce type de fichier. La valeur par défaut de cette clé est optionnelle mais, si elle est définie, elle doit contenir la liste des identificateurs des commandes possibles séparés par des points-virgules (.
Exemple
Code delphi : Sélectionner tout
open;edit;print.
Pour chaque commande vous devez créer une sous-clé de la clé shell dont le nom est l'identificateur de cette commande.
(dans l'explorateur, ces commandes sont les premières listées dans le menu contextuel lors d'un clic droit sur un fichier), par exemple :
Code delphi : Sélectionner tout
open
Vous pouvez éventuellement définir un nom pour cette commande via la valeur par défaut de cette clé, par exemple :
Code delphi : Sélectionner tout
&Ouvrir
L'esperluette, &, indique que la lettre qui la suit sera celle soulignée dans le menu. Chacune des clés de commandes doit comporter une sous-clé nommée command, dont la valeur par défaut est la chaîne de commande à exécuter. Cette valeur sera la plupart du temps de la forme : "Chemin_Complet_Exe_ou_DLL" "%1"
Par exemple :
Code delphi : Sélectionner tout
"C:\Windows\NotePad.exe" "%1"
Voici un autre exemple plus complexe :
Code delphi : Sélectionner tout
rundll32.exe C:\WINDOWS\System32\shimgvw.dll,ImageView_Fullscreen "%1"
Le %1 étant remplacé à l'exécution par le nom du fichier sélectionné dans l'exploreur.

Voici une procédure simple de recensement d'une extension avec l'application dans laquelle elle est exécutée. Il ne tient qu'à vous de l'adapter selon vos besoins.
Code delphi : Sélectionner tout
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 ne suffit pas de recenser l'extension, il faut également que l'application soit capable de reconnaître qu'on lui envoie un fichier. Ceci doit se faire au moyen des fonctions ParamCount et ParamStr de l'unité System, mais cela ne relève pas du sujet de cette question.

Mis à jour le 14 janvier 2014 sjrd

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 :

Code delphi : Sélectionner tout
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;
Exemple : Pour connaitre l'application associée à l'extension '.pas', il suffit d'appeler la fonction ExtToApp comme ceci:
Code delphi : Sélectionner tout
ShowMessage(ExtToApp('pas'));
Une autre méthode utilise l'API FindExecutable, définie dans l'unité ShellApi. Elle prend en paramètre un nom de fichier complet dont elle récupèrera elle-même l'extension pour en retrouver l'application associée :
Code delphi : Sélectionner tout
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;
Cette fonction est à utiliser dans le cas où vous souhaitez connaître l'application qui ouvre un fichier particulier :
Code delphi : Sélectionner tout
ShowMessage(AppPath('C:\Unit1.pas'));

Mis à jour le 14 janvier 2014 Bestiol delphichem sjrd

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,

et enfin ajoutez le code suivant dans l'événement OnClick de Button1 :
Code delphi : Sélectionner tout
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;
Correction proposée par sp00k

Mis à jour le 13 janvier 2014 delphi-fan

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.

Code delphi : Sélectionner tout
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;

Mis à jour le 13 janvier 2014 Sub0

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

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 © 2019 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et 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.

 
Responsables bénévoles de la rubrique Delphi : Gilles Vasseur - Alcatîz -

Partenaire : Hébergement Web