FAQ PascalConsultez toutes les FAQ

DLL est l'acronyme de Dynamic Linked Library, c'est-à-dire bibliothèque dynamiquement liée en français. Une DLL est une bibliothèque de routines qui peuvent être exécutées par un programme sans qu'elles soient contenues dans son fichier exécutable. À la différence d'une unité, qui est liée une fois pour toutes au programme au moment de la compilation, la DLL est liée dynamiquement au programme pendant son exécution.

Que peut contenir une DLL ?

• des procédures et fonctions (bien entendu) ;
• des objets ;
• des ressources binaires (dialogues, tables de chaînes, etc.).
  

La structure du fichier source d'une DLL est la suivante :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
  
Library MADLL; 
  
Uses Windows; 
  
Procedure MAPROC1 (x, y : Integer); export; 
Begin 
  ... 
End; 
  
Function MAFONC2 : Boolean; export; 
Begin 
  ... 
End; 
  
Exports   { Liste des routines exportables } 
  
  MAPROC1   index 1   name 'ProcPerso', 
  MAFONC2   index 2   name 'FoncPerso'; 
  
Begin 
  ...   { Code d'initialisation éventuel } 
End.

• le source doit commencer par le mot-clé library (à la place de program ou unit) ;
• chaque procédure ou fonction publique doit être accompagnée de la directive export ;
• la liste des routines exportées se trouve dans la section Exports ;
• dans la section Exports, chaque routine reçoit un n° d'index unique et, éventuellement, un alias (directive name).
  

On distingue deux méthodes d'importation : l'une, statique, dans laquelle les références des routines de la DLL sont connues et fixées dès le départ et l'autre, dynamique, dans laquelle on fait appel à des routines de l'API pour localiser les routines dans la DLL en cours d'exécution.

• Importation statique
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  
Unit MALIB; 
  
Interface 
  
Uses Windows; 
  
Procedure MAPROC1 (x, y : Integer); 
Function MAFONC2 : Boolean; 
  
Implementation 
  
Procedure MAPROC1;   external 'MADLL' index 1; 
Function MAFONC2;    external 'MADLL' index 2; 
  
End.

• Importation dynamique
  

• les changements apportés aux index des routines exportables d'une DLL ne nécessitent pas de recompiler l'unité d'import ainsi que les programmes qui l'utilisent ;
• seules les routines de la DLL utilisées par le programme doivent être déclarées, alors que l'unité d'import les déclare toutes : économie de symboles pour le compilateur ;
• un programme ayant recours à plusieurs DLL peut les charger et décharger à volonté.
  

1
2
3
4
5
6
  
Type tProc1 = Procedure (x, y : Integer); 
     tFonc2 = Function : Boolean; 
  
Var MaProc1 : tProc1; 
    MaFonc2 : tFonc2;

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
  
Type tProc1 = Procedure (x, y : Integer); 
  
Var MaProc1 : tProc1;   { Adresse de la routine } 
    hDLL : tHandle;     { Handle de la DLL } 
  
Begin 
  { Chargement de la DLL } 
  hDLL := LoadLibrary('MADLL.DLL'); 
  { Erreur si handle < 32 } 
  if hDLL >= 32 
     then 
       begin 
         { Recherche de la routine dans la DLL } 
         @MaProc1 := GetProcAddress(hDLL,'ProcPerso'); 
         if @MaProc1 <> Nil 
            then 
              begin 
                ... 
                { utilisation de la routine } 
                MaProc1(12,31); 
                ... 
              end 
            else 
              { Routine non trouvée } 
         { Déchargement de la DLL } 
         FreeLibrary(hDLL); 
       end 
     else 
       { Erreur de chargement de la DLL } 
End.