La création et l'utilisation de DLL

Pour ceux qui préfèrent la théorie avant la pratique, consultez les chapitres suivants.

Pour faire simple, utilisons l'expert DLL, Fichier -> nouveau -> Expert DLL.

Sinon, il vous faudra supprimer dans l'unité projet.prj le mot Program pour le remplacer par Library et supprimer la déclaration de l'unité Forms dans la clause Uses.
Supprimez aussi tout ce qui se trouve entre begin et end et supprimer la forme du projet, pour cet exemple, elle ne servira pas.

Nous allons commencer par la réalisation d'une DLL de fonction mathématique, libre à vous d'y ajouter d'autres fonctions par la suite. Enregistrez le projet sous le nom LibMaths.

Notre première fonction sera la fonction factorielle. Bref rappel de math, la factorielle de 1 vaut 0 et la factorielle de 0 vaut 1. On note l'opération factorielle : n! où n est un nombre entier positif et ! l'opérateur. Le produit factoriel de n vaut n multiplier par le produit factoriel de n-1 (pour les esprits vifs que vous êtes, cette définition vous fait penser à la récursivité). Exemple : 3! = 3*2! = 3*2*1! soit 3*2*1 donc 6. et 4! = 4*3! = 4*6 soit 24. Pour ceux qui ne connaissent pas la récursivité, pas d'inquiétude, car ce n'est pas le sujet du cours, l'essentiel est de comprendre le principe.

• Pour partir sur de bonnes bases, votre projet doit ressembler à ceci :

library LibMaths;

uses
    Windows;

begin

end.

• Nous allons coder notre fonction factorielle entre la clause uses et le begin principal, soit :

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

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

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

    Windows;

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, enregistrez votre projet si ce n'est déjà fait et commencez un nouveau projet.

Dans la Form, ajoutez un composant 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 implementation 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) ajoutez le mot réservé external 'nom du fichier de la 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.

Si vous avez lu les chapitres précédents, le premier mot-clé nouveau fut library. Ce mot indique au compilateur qu'il ne s'agit pas d'un programme principal (contenant main) et donc sans point d'entrée de type winmain. Ensuite la partie entre begin et end final correspond, comme pour les projets, à la partie initialisation. Dans cette section, vous pouvez initialiser les variables globales. Voilà pour les détails.

exports : permet de lister les fonctions à rendre visible/accessible depuis l'extérieur.
On peut y ajouter des options :

• name : renomme la fonction exportée, par exemple quand le nom de la fonction existe déjà ailleurs ;
  exports sqrt name 'sqrtv2';
  Exporte la fonction sqrt sous le nom sqrtv2, car sqrt existe déjà, c'est sqrtv2 qu'il faudra utiliser dans les applications utilisant cette DLL. Attention à la casse ;
• index : il spécifie un index pour la clause exports. 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 sqrtv2 index 5;
  La fonction sqrtv2 sera accessible par l'indice 5.

Ces options sont cumulables, on peut exporter une fonction par nom et par index (sqrt name 'sqrtv2' index 5;).
Les noms des fonctions exportées sont sensibles à la casse (c'est-à-dire qu'il y a une différence entre majuscules et minuscules).

• stdcall : c'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 pour une 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 langage C.

Exemple avec notre DLL :

• Dans le projet DLL, on ajoute la convention d'appel à la fin de la déclaration de la fonction. Remarquez le mot export (sans s) qui se place après la convention d'appel 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 d'appel

implementation

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

{$R *.DFM}

Importation :

• Importation par nom : on reprend la déclaration de la DLL et on ajoute external 'nom du fichier de la DLL' sans l'extension
  function sqrtv2(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 sqrt(n : integer): integer; stdcall; external 'NomDLL' name 'sqrtv2'
  Où sqrtv2 est le nom de la fonction dans la DLL et sqrt le nom de la fonction dans l'application.
  Attention, pas de ';' entre les clauses external et name.
• Importation par index : pas grand-chose à dire, donc un exemple :
  function sqrt(n : integer): integer; stdcall; external 'NomDLL' index 10;

II-B-1. DLL de classe▲

Les DLL permettent aussi d'exporter des classes à condition de comprendre quelques subtilités liées aux classes. Commençons par définir une classe dans un projet DLL (Nouveau-> expert DLL). Ajoutez une nouvelle unité (Nouveau->Unité) qui contiendra notre classe et commençons sa définition.

 

Sélectionnez

unit MaClassDLLUnt;

interface

type
    TMaClass = class

    private
        Test : integer;

    public
        function GetTest : integer; virtual; stdcall; export;
        procedure SetTest(NewValeur : integer); virtual; stdcall; export;

    end;

implementation

function TMaClass.GetTest:integer; stdcall; export;
begin
    // Renvoie la valeur de la variable Test
    Result := Test;
end;

procedure TMaClass.SetTest(NewValeur : integer); stdcall; export;
begin
    // Change la valeur de la variable Test en NewValeur
    Test := NewValeur;
end;

end.

• J'ai déjà indiqué 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 fonctions, c'est donc la classe qu'il nous faut exporter. Voici comment procéder :

 

Sélectionnez

function CreeInstanceMaClass : TMaClass; export; // Pas de virtual ici !

begin
    Result := TMaClass.Create;
end;

• Dans la section exports, on exporte seulement cette fonction. On exporte la classe depuis le fichier source à savoir celui avec le mot library, c'est-à-dire le projet courant

Le code complet de la page principale

Sélectionnez

library Dll_ClassPrj;
uses
    SysUtils,
    Classes,
    MaClassDLLUnt in 'MaClassDLLUnt.pas';

{$R *.res}

exports
    CreeInstanceMaClass; // seule la fonction permettant d'instancier (créer) un objet de la classe est exportée !

begin

end.

L'unité contenant la définition de la classe

 

Sélectionnez

unit MaClassDLLUnt;
interface

type
    TMaClass = class

    private
        Test : integer;

    public
        function GetTest : integer; virtual; stdcall; export;
        procedure SetTest(NewValeur : integer); virtual; stdcall; export;

    end;

    function CreeInstanceMaClass() : TMaClass; stdcall; export; // Pas de virtual ici !

implementation

function TMaClass.GetTest:integer; stdcall; export;
begin
    // Renvoie la valeur de la variable Test
    Result := Test;
end;

procedure TMaClass.SetTest(NewValeur : integer); stdcall; export;
begin
    // Change la valeur de la variable Test en NewValeur
    Test := NewValeur;
end;

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

end.

Téléchargez le code source de la Dll

Voilà pour la DLL, nous allons maintenant créer une application l'utilisant. Contrairement à ce qui avait été dit auparavant export ne sera pas la dernière déclaration dans l'importation des fonctions. Il s'agit d'abstract qui terminera nos déclarations. Pourquoi ? Eh bien parce que ! Mais plus sérieusement, pour pouvoir utiliser une classe, il faut que l'application connaisse sa définition. C'est pourquoi nous avons déclaré toutes nos méthodes (le nom des fonctions quand elles sont dans une classe) virtuelles (Virtual) et que nous utilisons le mot-clé abstract qui permet de mettre la définition sans implémenter les méthodes. (Pour plus de précision, voir les cours sur les classes, comme celui de  Frédéric BEAULIEU.)

Dans un nouveau projet, voici pour l'apparence :

Ensuite, repérez la fin de la déclaration de la Form et ajoutez la définition de la classe contenue dans la DLL. Il suffit de recopier sa déclaration et d'ajouter abstrac à la fin de chaque méthode exportée. Après les directives de compilation ({$R *.DFM}), importez la fonction qui permet de créer une instance de la classe.
Voici le code complet :

 

Sélectionnez

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 la variable Testn, car l'utilisateur ne devrait jamais
        // manipuler directement cette valeur, voir les classes
        // pour comprendre la philosophie sous-jacente.
        // pas de déclaration de : Test : integer;
    public
        function GetTest : integer; virtual; stdcall; export; abstract;
        procedure SetTest(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 concentré sur le sujet : les DLL
    // Crée une instance de la classe
    MaClass := CreeInstanceMaClass();

    // Affecte une nouvelle valeur à la variable Test
    MaClass.SetTest(StrToInt(edNouvValeur.Text));

    // Récupère la valeur de la variable Test puis l'affiche
    lbValeur.Caption := IntToStr(MaClass.GetBidon);

    // Libère la classe
    MaClass.Free;
end;

end.

Téléchargez le code source de la partie utilisation ici

Nous allons réaliser une petite calculette sans prétention. Le but est d'apprendre à utiliser des composants Delphi dans une DLL et de voir quelques écueils.

Commencez un nouveau projet DLL et ajoutez une fiche. Enregistrer le projet (PMaDLL) et l'unité (UMadll). Dans la fiche, ajoutez les composants et changez la propriété BorderStyle de la fiche à bsDialog, de façon à obtenir ce résultat :

Le bouton égal est obtenu en mettant le signe '=' dans Caption et le signe '+' par un label avec une fonte différente :)
Dans la clause Uses, ajoutez l'unité Forms avant l'unité UMadll.

• Ajoutez le code suivant dans l'événement OnClick du bouton '=' :

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
        // Affiche la forme de manière modale (attend sa fermeture)
        ShowModal;
        // Renvoie le résultat du calcul
        Result := StrToFloat(Label3.Caption);
    end;
end;

• et ajouter une version procédure qui ne sera utilisée que dans le chapitre autres langages (plus avant dans ce cours).

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

• Pour terminer notre DLL exportons nos fonctions :

exports
   Creer_Form, Free_Form,
   fncsomme, proSomme;

Réalisons maintenant une application qui utilisera cette DLL. Enregistrez votre projet DLL si ce n'est déjà fait et commencez un nouveau projet application. Nous allons faire simple et nous contenter d'un bouton pour appeler la calculette et d'un label pour afficher le résultat, nous mettrons aussi la fiche en bsdialog.

L'apparence étant faite, passons au codage. Il nous faut importer les fonctions permettant de manipuler la DLL. Donc nous allons importer les fonctions qui permettent de créer la form, de la libérer et bien sûr d'utiliser la calculette.
Juste après les directives de compilation ( {$R *.DFM} ) ajoutez :

procedure Creer_Form; stdcall; external 'pMadll.dll';

procedure Free_Form; stdcall; external 'pMadll.dll';

function Total:Double; stdcall; external 'pMadll.dll' name 'fncsomme';

• Au niveau de la Function, vous aurez remarqué que j'ai renommé la fonction Total.
• Dans l'événement OnClick du Bouton 'Appel de la Calculette', saisissez 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;

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

Si votre DLL doit utiliser des paramètres de type chaînes longues (String), vous allez vous heurter à un problème. Heureusement deux solutions s'offrent à vous :

• la plus simple, utiliser l'unité ShareMem en la 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 a 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 les type PChars ou ShortStrings. En ce qui concerne les ShortStrings, ils se manipulent comme le type String si ce n'est le nombre limité de caractères qu'une chaîne de ce type peut contenir.

Je ne parlerai ici que des chaînes de caractères de type PChars et de leur utilisation avec les DLL, le reste ne posant pas de difficulté. Tout d'abord un PChar est une chaîne un peu spéciale (avec un nom pareil, c'est évident que ça va être bizarre). Un Pchar est un pointeur sur une chaîne de caractères (tableau de Char) terminée par un indicateur de fin. Une bonne nouvelle lorsqu'on les manipule sous delphi, ils sont compatibles avec les String.

MonPChar := MonString;

Par contre, l'indicateur de fin est le caractère #0. Du coup ce caractère ne doit pas se retrouver dans la chaîne (la chaîne s'arrête dès qu'elle rencontre celui-ci). Cet indicateur de fin est aussi appelé null ou Zéro Terminal.
Le point le plus délicat est l'espace mémoire occupé par ces PChars, contrairement au string, il est fixe. Mais avant d'entrer dans le vif du sujet un exemple d'utilisation vous permettra de fixer les choses :

• soit MaFonction : une fonction qui attend une chaîne de caractères 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 la variable S, car c'est un pointeur donc une adresse (sinon vous passez une adresse d'une adresse O_o)
• si nous voulons utiliser cette fonction, on aura :

var
    U : array[0..51] of Char; // Déclaration d'une chaîne de caractères

begin
    U := 'affectation d''une valeur';
    MaFonction(U, sizeof(U));
    ... suite des instructions...
end;

Dans le passage de paramètre, on passe un pointeur sur la chaîne de caractères soit U par adresse et la taille de la chaîne. Quoi que fasse la fonction MaFonction, elle ne devra pas dépasser cette taille-1 (pensez au caractère de fin de chaîne).
Pour copier une chaîne dans un Pchar en limitant la taille d'arrivée, vous pouvez utiliser la fonction StrPLCopy

  StrPLCopy(VariablePChar, MonString, TailleMaxi);

On peut très bien se passer des tableaux de caractères en utilisant tout de suite un PChar. Dans ce cas, il faut allouer de l'espace mémoire avant de les utiliser. Le code précédent deviendrait :

var
    U : PChar; // Déclaration d'un pointeur sur une chaîne de caractères

begin
 U := StrAlloc(50);
 StrLPCopy(U, 'affectation d''une valeur', 49);
 MaFonction(U, 50); // N'utilisez pas la taille de U surtout ! c'est-à-dire SizeOf(U)
 ... suite des instructions...
end;

Les notions vues ici sont aussi valables pour transmettre d'autres types de tableaux pas seulement des tableaux de caractères. Il suffit de remplacer les pointeurs PChar par un pointeur sur votre tableau.

Exemple avec un tableau de Double.

• Dans l'application, on déclare le tableau normalement et on ne transmet que le premier élément par adresse. En transmettant le premier élément par adresse, on passe en fait un pointeur sur le tableau. On peut aussi utiliser un vrai pointeur, mais pourquoi se fatiguer ?

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 transmis
    pMat := @T;

    for i:=0 to taille do
        pMat^[i] := pMat^[i] + 1.33;
end;

Vous trouverez un tutoriel dédié à ce sujet ici. (Remerciez Laurent Dardenne, car c'est lui qui m'a fourni le lien.)