Guide Pascal et Delphi

Date de publication : 10/04/2000 , Date de mise à jour : 01/04/2008

XVIII. DLL

XVIII-A. Introduction

• La principale est qu'elle permet de partager ses ressources avec tout le monde. Vous pouvez distribuer ou récupérer une dll et ensuite l'utiliser ses ressources. Exemple si vous créez ou récupérer une DLL contenant des fonctions mathématiques, vous n'avez plus besoin de les réaliser dans votre application, il suffit de les importer. Leur utilisation se fait alors comme celle que l'on trouve dans Delphi comme sqrt.
• La seconde est qu'elle permet de découper son application en morceau afin d'améliorer la maintenance et le débogage. Si vous modifier une partie du code dans une dll, il vous suffit de redistribuer votre dll pour mettre l'application à jour. Cela permet aussi de séparer par fonctionnalité votre code. Je dois dire que l'intérêt de ce point est un peu flou. Il est quasiment inexistant pour les petites applications, il suffit de faire plusieurs unités et on peut aussi utiliser l'héritage, je ne parle pas ici de l'héritage des classes quoique mais de celui des unités(Pour Rappel : on peut inclure des unités dans son projet en spécifiant qu'ils ne sont qu'une copie de l'original ou un lien, ce qui implique qu'elles se mettent à jour si l'original est modifié). Reste le problème de la compilation qui concerne tout le projet au contraire de la DLL où seul la dll concernée est à recompiler.
• Le troisième est que l'on peut charger dynamiquement une DLL. Quand une DLL est chargée dynamiquement dans une application, elle ne réside en mémoire que lorsqu'elle est utilisée (appelé) et ensuite la mémoire est libérée (la dll est déchargée).

XVIII-B. Ecriture des DLLs & Utilisation

XVIII-B-1. DLL de fonction

• Pour partir sur de bonne base, votre projet doit ressembler à ceci :

  library LibMaths; { Remarque importante concernant la gestion de mémoire de DLL : ShareMem doit être la première unité de la clause USES de votre bibliothèque ET de votre projet (sélectionnez Projet-Voir source) si votre DLL exporte des procédures ou des fonctions qui passent des chaînes en tant que paramètres ou résultats de fonction. Cela s'applique à toutes les chaînes passées de et vers votre DLL --même celles qui sont imbriquées dans des enregistrements et classes. ShareMem est l'unité d'interface pour le gestionnaire de mémoire partagée BORLNDMM.DLL, qui doit être déployé avec vos DLL. Pour éviter d'utiliser BORLNDMM.DLL, passez les informations de chaînes avec des paramètres PChar ou ShortString. } uses SysUtils, Classes; {$R *.res} begin end.

• Entre le windows et le begin, nous allons coder notre fonction factorielle soit :

  function Factorielle(n : integer): integer; begin // On n'aurait pu traité le cas 0 et 1 séparement mais cela fait un test de plus if n = 0 then Result := 1 else Result := n * Factorielle(n-1); end;

  Vérifiez bien que la fonction puisse s'arrêter quand vous faites de la récursivité sinon vous créez une boucle infinie.

• Maintenant, nous allons exporter notre fonction pour qu'elle puisse être utilisée par d'autre application. Entre le end de la fonction et le begin du projet, tapez :

  exports Factorielle;

  Le code source complet doit ressembler à ceci. Mais attention, il ne s'agit pas d'un exécutable, vous ne pouvez que le compiler. Pour ce faire, Tapez CTRL+F9 ou Projet -> Compiler LibMaths.

  library LibMaths; uses SysUtils, Classes; function Factorielle(n : integer): integer; begin if n = 0 then Result := 1 else Result := n * Factorielle(n-1); end; exports Factorielle; begin end.

  Nous allons maintenant nous attaquer à la programmation d'une application utilisant cette dll. Pour cela enregistrer votre projet si ce n'est déjà fait et commencez un nouveau projet.
  
  Dans la Form ajouter un EditBox pour la saisie de l'utilisateur et un Label ou EditBox pour afficher le résultat plus d'autres labels pour documenter votre application. Ajoutez aussi deux boutons l'un pour calculer et l'autre pour fermer. Pour le bouton Fermer vous pouvez utiliser un BitBt (onglet : Supplément) et positionner sa propriété Kind à bkClose.
  
  
• Entre Implémentation et les directives de compilation, importez la fonction. L'importation se fait en reprenant la déclaration de la fonction soit ici : function Factorielle(n : integer): integer; Attention à la casse (il faut le f majuscule) ajouter le mot reservé external 'nom du fichier dll'; sans l'extension.

  implementation function Factorielle(n : integer): integer; external 'LibMaths'; {$R *.DFM}

• On peut maintenant utiliser cette fonction, dans l'événement onclick du bouton Calculer, ajouter le code suivant :
  Remarque : Il n'y a pas de test sur la saisie de l'utilisateur dans un souci de clarté !

  procedure TForm1.btTestClick(Sender: TObject); var n : integer; begin n := StrToInt(Edit1.Text); lbResultat.Caption := IntToStr(Factorielle(n)); end;

• Exécutez et testez votre application. Notez que le fichier dll doit se trouver dans le même répertoire que l'application l'utilisant ou dans le répertoire window ou window/systeme (à éviter cependant sauf cas particulier comme les dll de windows :) ).

unit PrincipalFrm;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Buttons, Mask;

type
  TForm1 = class(TForm)
    BitBtn1: TBitBtn;
    Label1: TLabel;
    btTest: TButton;
    lbResultat: TLabel;
    Edit1: TEdit;
    procedure btTestClick(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;

var
  Form1: TForm1;

implementation

function Factorielle(n : integer): integer; external 'LibMaths';

{$R *.DFM}

procedure TForm1.btTestClick(Sender: TObject);
var
  n : integer;
begin
  n := StrToInt(Edit1.Text);
  lbResultat.Caption := IntToStr(Factorielle(n));
end;

end.

XVIII-B-2. Théorie & Subtilité

• name : renomme la fonction exportée, par exemple quand le nom de la fonction existe déjà ailleurs.
  exporte la fonction toto sous le nom titi, c'est titi qu'il faudra utiliser dans les applications utilisant cette dll. Attention à la casse.

  exports Toto name 'titi';

  exporte la fonction toto sous le nom titi, c'est titi qu'il faudra utiliser dans les applications utilisant cette dll. Attention à la casse.
  
  
• index : il spécifie un index pour la fonction exporter. Toutes les fonctions sont indexées, si on change l'index d'une fonction les index des fonctions suivantes reprennent à partir de celui-ci. N'est plus utilisé en environnement 32 bits (win98 et +) car le gain de performance est négligeable.

  exports Toto index 5;

  La fonction Toto sera accessible par l'indice 5.
  
  

exports
  Toto index 5;

• stdcall : qui est la convention par défaut mais il est bon de le préciser quand même (en cas d'évolution du langage). Cette convention permet d'exporter ces fonctions dans une grande majorité des langages. Elle est apparue avec les systèmes 32 bits.
• register : permet de placer les paramètres dans les registres donc d'optimiser leur vitesse d'accès.
• pascal : utilise une convention propre au Pascal.
• cdecl : Convention du c.

Si vous voulez connaitre plus en détail les différences entre les conventions, allez ici : Conventions d'appel

• Dans le projet dll, on ajoute la convention à la fin de la fonction. Remarquez le mot export (sans s) qui se place après la convention et notez qu'il n'est pas obligatoire.

  function Factorielle(n : integer): integer; stdcall; export; begin if n = 0 then Result := 1 else Result := n * Factorielle(n-1); end;

• Dans le projet utilisant la dll, on rajoute la même convention

  implementation function Factorielle(n : integer): integer; stdcall; external 'LibMaths'; {$R *.DFM}

• Importation par nom : on reprend la déclaration de la Dll et on ajoute external 'nom du fichier dll sans l'extension'
  function Toto(n : integer): integer; stdcall; external 'NomDLL';
  On peut aussi changer le nom de la fonction sous lequel on veut la manipuler dans l'application ex :
  function Machin(n : integer): integer; stdcall; external 'NomDLL' name 'Toto'
  Où Toto est le nom de la fonction dans la DLL et Machin le nom de la fonction dans l'application. Attention, pas de ';' entre external et name.
• Importation par index : par grand chose à dire donc un exemple :
  function Machin(n : integer): integer; stdcall; external 'NomDLL' index 10;

Manipulation des chaînes Longues : Si vous avez utilisé l'Expert Dll, vous avez pu remarquer un commentaire vous mettant en garde sur l'utilisation des chaînes longues. Cette mise garde ne concerne que la manipulation des chaînes comme paramètre, c'est à dire entrant ou sortant de la dll (en interne, pas de problème). En effet, Delphi gère les chaînes longues d'une façon qui est incompatible avec les autres langages. Vous avez lors deux solutions soit utiliser ShareMem et inclure la dll : BORLNDMM.DLL avec votre application, soit utiliser des PChar ou ShortString (voir le chapitre XVIII.B.5. DLL & Chaîne de caractère). Attention même les chaînes qui sont dans des enregistrements ou des classes sont concernées ! Voir le chapitre Chargement Statique/Dynamique pour les importations avancées.

XVIII-B-3. DLL de Classe

unit MaClassDLLUnt;

interface

type
  TMaClass = class
  private
    bidon : integer;
  public
    function GetBidon() : integer; virtual; stdcall; export;
    procedure SetBidon(NewValeur : integer); virtual; stdcall; export;
  end;

implementation

function TMaClass.GetBidon():integer; stdcall; export;
begin
  // Renvoie la valeur de bidon
  Result := Bidon;
end;

procedure TMaClass.SetBidon(NewValeur : integer); stdcall; export;
begin
  // Change la valeur de bidon en NewValeur
  Bidon := NewValeur;
end;

end.

• J'ai déjà noté les fonctions que je voulais exporter mais les déclarer dans la partie exports ne serait pas suffisant. Nous manipulons ici une classe et non un ensemble de fonction, c'est donc la classe qu'il nous faut exporter. Voici comment procéder :

  function CreeInstanceMaClass() : TMaClass; export; // Pas de virtual ici ! begin Result := TMaClass.Create; end;

• Dans la partie exports, on exporte seulement cette fonction. On exporte la classe depuis la page principal soit celle avec le mot library
  Le code complet de la page principal puis de l'unité contenant la définition de la classe :

  // Page principal library Dll_ClassPrj; uses SysUtils, Classes, MaClassDLLUnt in 'MaClassDLLUnt.pas'; {$R *.res} exports CreeInstanceMaClass; // Seul la fonction permettant d'instancier(créer) un objet de la classe est exporté ! begin end. // Unité contenant la définition de la classe unit MaClassDLLUnt; interface type TMaClass = class private bidon : integer; public function GetBidon() : integer; virtual; stdcall; export; procedure SetBidon(NewValeur : integer); virtual; stdcall; export; end; function CreeInstanceMaClass() : TMaClass; stdcall; export; // Pas de virtual ici ! implementation function TMaClass.GetBidon():integer; stdcall; export; begin // Renvoie la valeur de bidon Result := Bidon; end; procedure TMaClass.SetBidon(NewValeur : integer); stdcall; export; begin // Change la valeur de bidon en NewValeur Bidon := NewValeur; end; function CreeInstanceMaClass() : TMaClass; stdcall; export; // Pas de virtual ici ! begin Result := TMaClass.Create; end; end.

unit UtilDll_ClassUnt;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls;

type
  TForm1 = class(TForm)
    edNouvValeur: TEdit;
    Label1: TLabel;
    lbValeur: TLabel;
    btManipClasse: TButton;
    Label2: TLabel;
    procedure btManipClasseClick(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;

type
  TMaClass = class
  private
    // On n'importe pas Bidon car l'utilisateur ne devrait jamais
    // Manipuler directement cet valeur, voir les classes
    // pour comprendre la philosophie sous jascente.
    // pas de : bidon : integer;
  public
    function GetBidon() : integer; virtual; stdcall; export; abstract;
    procedure SetBidon(NewValeur : integer); virtual; stdcall; export; abstract;
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

function CreeInstanceMaClass() : TMaClass; stdcall; external 'Dll_ClassPrj'; // Pas d'abstract ici, ce n'est pas une méthode !

procedure TForm1.btManipClasseClick(Sender: TObject);
var
  MaClass : TMaClass;
begin
  // La classe ne fait pas grand chose
  // mais permet de rester concentrer sur le sujet : les dll
  // Crée une instance de la classe
  MaClass := CreeInstanceMaClass();
  // Affecte une nouvelle valeur à bidon
  MaClass.SetBidon(StrToInt(edNouvValeur.Text));
  // recupère la valeur bidon et l'affiche
  lbValeur.Caption := IntToStr(MaClass.GetBidon);
  // libère la classe
  MaClass.Free;
end;

end.

XVIII-B-4. DLL de Composant

Le bouton égal est obtenu en mettant le signe '=' dans Caption et le plus par un label avec une fonte différente

• Dans l'événement OnClick du bouton égal :

  procedure TMaForm.Button1Click(Sender: TObject); begin Label3.Caption := FloatToStr(StrToFloat(Edit1.Text) + StrToFloat(Edit2.Text)); end;

• J'ai renommé Form1 en MaForm pour la suite !
• Retournez sur l'unit Projet, Il nous faut donner le moyen à l'application de créer la Form car vous remarquerez qu'il n'y a pas de création automatique contrairement aux exécutables.

  procedure Creer_Form; stdcall; export; begin // Crée une instance de Form DecimalSeparator := '.'; // change le séparateur décimal Application.CreateForm(TMaForm, MaForm); MaForm.Label3.Caption := '0'; end;

• Comme nous créons la Form, nous allons nous donner le moyen de la libérer

  procedure Free_Form; stdcall; export; begin // Libère la Form MaForm.Free; end;

• Nous allons maintenant ajouter une fonction retournant la somme calculée.

  function fncsomme():Double; stdcall; export; begin with MaForm do begin // Montre la forme et attend sa fermeture ShowModal; // Renvoi le résultat du Calcul Result := StrToFloat(Label3.Caption); end; end;

• Et une version procédure qui ne sera utilisé que dans le chapitre autre langages.

  procedure proSomme(var R: Double); stdcall; export; begin with MaForm do begin // Montre la forme et attend sa fermeture ShowModal; // Modifie la variable R (passage par adresse) R := StrToFloat(Label3.Caption); end; end;

• Exportons nos fonctions et notre DLL sera terminée

  exports Creer_Form, Free_Form, fncsomme, proSomme;

procedure Creer_Form; stdcall; external 'pMadll.dll';
procedure Free_Form; stdcall; external 'pMadll.dll';
function Total():Double; stdcall; external 'pMadll.dll' name 'fncsomme';

• A niveau de la Function, vous aurez remarqué que j'ai changé le nom de la fonction pour Total.
• Dans l'événement OnClick du Bouton 'Appel de la Calculette', Tapez le code suivant (fmUseDll est le nom de ma Form) :

  procedure TfmUseDLL.btAppelCalculetteClick(Sender: TObject); var R : Double; begin Creer_Form; R := Total(); lbResultat.Caption := FloatToStr(R); // Ne pas oublier de libérer la form à la fin Free_Form; end;

• Enregistrer votre projet et vérifiez que la DLL se trouve dans le même répertoire que la casse des fonctions importés est correct.
  Lancez votre appli, vous disposez maintenant d'une dll proposant une calculette :)

XVIII-B-5. DLL & Chaîne de caractère

• La plus simple utiliser l'unité ShareMem en le déclarant dans la clause uses avant toutes les autres déclarations. Vous pouvez alors utiliser les chaînes longues comme bon vous semble. Cette méthode bien que simple à un gros inconvénient, pour que votre application puisse fonctionner, il lui faut alors une autre dll. Le problème et qu'il ne faut pas oublier de fournir cette dll sous peine d'empêcher l'exécution de votre application. le fichier dll à inclure : BORLNDMM.DLL.
• La plus indépendante, utilisez des PChars ou des ShortStrings. En ce qui concerne les ShortStrings, ils se manipulent comme les strings si ce n'est le nombre limit de caractère qu'ils peuvent contenir.

Attention même les chaînes qui sont dans des enregistrements ou des classes sont concernées !

• Soit MaFonction : une fonction qui attend une chaîne de caractère de type PChar qui la manipule et la renvoie. Le détail de la fonction n'est pas ce qui nous intéresse.

  function MaFonction(S :PChar; Taille : integer);

  On ne met pas var devant S car c'est un pointeur donc une adresse (passer une adresse d'une adresse :o )
  
  
• Dans une partie du code nous voulons utiliser cette fonction, soit :

  var U : array[0..51] of Char; // Déclaration d'une chaîne de caractère begin U := 'affectation d''une valeur'; MaFonction(U, sizeof(U)); ... Suite des instructions... end;

StrPLCopy(VariablePChar, MonString, TailleMaxi);

var
  U : PChar; // Déclaration d'un pointeur sur chaîne de caractère
begin
  U := StrAlloc(50);
  StrLPCopy(U, 'affectation d''une valeur', 49);
  MaFonction(U, 50); // Pas de Size de U surtout !
  ... Suite des instructions...
end; 

• Dans l'application, on déclare le tableau normalement met on ne transmet que le premier élement par adresse. En transmettant le premier élément par adresse, on passe en fait un pointeur sur le tableau. On n'aurait pu utilisé un vrai pointeur.

  var Mat : array[0..5] of double; begin for i:=0 to 5 do Mat[i] := 0; TransmettreMat(Mat[0], 5); // On transmet aussi la Taille ! end;

• Dans la DLL, la fonction attend un paramètre par adresse (le pointeur sur le tableau) et la taille.

  procedure transTableau(var T : Double;taille : integer);stdcall;export; type TTabMat = array[0..6] of double; PTabMat = ^TTabMat; var i : integer; pMat : PTabMat; begin // fixe le séparateur décimal DecimalSeparator := '.'; // fait pointer pMat sur l'adresse de T donc sur le tableau transmit pMat := @T; for i:=0 to taille do pMat^[i] := pMat^[i] + 1.33; end;

XVIII-C. Chargement statique/dynamique

Handle := loadlibrary('MonfichierDll.dll');

@MaFonction := GetProcAddress(Handle, 'nomdelafonctiondanslaDLL');

FreeLibrary(Handle);

unit PrincipalFrm;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, Buttons, Mask;

type
  TForm1 = class(TForm)
    BitBtn1: TBitBtn;
    Label1: TLabel;
    btTest: TButton;
    lbResultat: TLabel;
    Edit1: TEdit;
    procedure btTestClick(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.btTestClick(Sender: TObject);
var
  n : integer;
  Handle: THandle;
  MaFactorielle: TMyProc;
begin
  n := StrToInt(Edit1.Text);
  // Charge une dll dynamiquement et la libère ensuite 
  Handle := loadlibrary('LibMaths.dll'); // Charge la dll

  if Handle <> 0 then
  begin
    try
      // Charge dynamiquement une fonction de la dll
      @MaFactorielle := GetProcAddress(Handle, 'Factorielle');
      if @MyProc <> nil then
      begin
        lbResultat.Caption := IntToStr(MaFactorielle(n));
      end;
    Finally
      FreeLibrary(Handle); //Assure le déchargement de la dll
    end; // Try..Finally
  end
  else
    ShowMessage('Impossible de charger la DLL');
end;

end.

Libération des ressources : Remarquez l'imbrication du try..finally : On essaie d'abord de charger la dll si l'opération réussit (ici traité par un if mais un try..except est tout à fait valable), on rentre dans un bloc protégé (try) même si une exception arrive la ressource sera libérée car elle est dans la partie finally. Par contre, ce serait une erreur de mettre loadlibrary dans le code protégé.

XVIII-D. DLL et Autres Langages

Private Declare Sub CreerFormDll Lib "PMadll.dll" Alias "Creer_Form" ()
Private Declare Sub FreeFormDLL Lib "PMadll.dll" Alias "Free_Form" ()
Private Declare Function DllTotal Lib "PMadll.dll" Alias "fncsomme" () As Double

Private Sub btAppelCalculette_Click()
  CreerFormDll
  lbResultat.Caption = DllTotal
  ' N'oublions pas de libérer la Form
  FreeFormDLL
End Sub 

DLL UNLOAD ALL
! Change le répertoire en cours
MASS STORAGE IS "D:\delphi\Utilisation_de_la_DLL_par_HTB\dll"
! Charge la DLL
DLL LOAD "pMaDll"
! Importe les fonctions et les renomme.
DLL GET "STDCALL VOID pMaDll:Creer_Form" AS "Creerformdll"
DLL GET "STDCALL VOID pMaDll:Free_Form" AS "Freeformdll"
DLL GET "STDCALL VOID pMaDll:proSomme" AS "Dlltotal"

! rechange de répertoire
MASS STORAGE IS "D:\delphi\Utilisation_de_la_DLL_par_HTB"
! Un peu de ménage
CLEAR SCREEN

! Affiche à l'écran toutes les fonctions disponibles dans la dll (pas seulement celle qui sont importées)
LIST DLL

REAL R

! Crée la Form
Creerformdll
! Affiche la Form en Modal (Mécanisme interne de la fonction DllTotal)
Dlltotal(R)
! Libère la form
Freeformdll
! Affiche le résultat à l'écran
PRINT R
! Décharge la DLL et oui en HTB, il faut tout faire soi même ;)
DLL UNLOAD ALL
! Fin
END

XVIII-E. Conclusion

Petite astuce de débogage : Pour explorer le code de votre dll pendant l'exécution, ouvrez votre projet dll dans exécuter choisissez paramètre et indique une application exploitant votre dll dans Application hôte. la dll se comporte alors comme si elle était exécutable, vous pouvez placer des points d'arrêt, faire du pas à pas ...