Écrire et utiliser un objet dans une DLL avec Delphi

Michaël Moreno

De la même façon qu’il ne viendrait pas à l’idée à un programmeur d’écrire les milliers de lignes de son programme dans un seul fichier, il ne viendrait pas à l’idée du programmeur professionnel de livrer son programme en un seul fichier. Certains considèrent que de ne livrer qu’un seul fichier est un avantage pour la maintenance et la livraison du produit. C’est en effet le cas pour les petits produits créés par des débutants/amateurs, mais sûrement pas pour le professionnel ayant un parc de logiciels à maintenir et à faire évoluer éventuellement à l’aide de mises à jour par Internet.

Découper l’exécutable comme l’on découpe le code source est l’une des clés de la réussite de la maintenance et du développement de progiciels. Il existe plusieurs techniques de démembrement de l’exécutable. L’une d’entre elles repose sur l’utilisation de DLL (Dynamic Linked Library).

Les DLL permettent de regrouper un sein d’un fichier plusieurs méthodes (fonctions ou procédures) que l’on utilise depuis un programme extérieur. Plusieurs programmes pourront utiliser cette même DLL ce qui permet de gagner du temps de développement de logiciels. La mise à jour de la DLL permet de mettre à jour tous les programmes l’utilisant sans avoir à les recompiler. Le gain en temps de maintenance est souvent significatif.

Les DLL peuvent être chargées statiquement ou dynamiquement. Le chargement dynamique plus difficile à mettre en œuvre possède un avantage considérable, celui de permettre la programmation des fameux plug-ins.

De nos jours, même si la technologie COM (Component Object Model) s’impose de plus en plus il faut reconnaître que les DLL ont encore de belles journées devant elles. La raison est simple. Le développement et la maintenance d’objet COM restent assez difficiles pour le programmeur. En revanche, quel plaisir de développer l’application cliente !

Dans ce bref article, la programmation des objets au sein des DLL à l’aide de Delphi 6 est présentée de manière concise. Il est supposé que le programmeur connaît déjà le langage Pascal Objet. L’ensemble des étapes essentielles est détaillé à l’aide de captures partielles d’écran. Le programmeur non habitué au développement de DLL est en mesure de réaliser et mettre en œuvre sa première DLL avec cet exemple sans aucune difficulté. Les sources de l’exemple sont disponibles.

Téléchargez les sources de l'article (zip 32 Ko).

- Titre : Écrire et utiliser un objet dans une DLL avec Delphi

- Auteur : Michaël Moreno

- Parution : 4 novembre 2001

- Mise à jour : 5 janvier 2020

- Licence : Copyright ® 2001 Michaël Moreno. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Écriture de la DLL

- I-A. Création du projet de la DLL

- I-B. Écriture de l’objet

- I-C. Écriture du code source du projet de la DLL

- II. Écriture de l’application utilisant la DLL

- II-A. Création d’un nouveau projet

- II-B. Écriture de l’unité d’importation de l’objet

- II-C. Utilisation de l’objet

- III. Conclusion

I - Écriture de la DLL

I-A - Création du projet de la DLL

Dans le menu Fichier, cliquer sur Nouveau puis sur Autre…

Dans la boîte de dialogues qui apparaît, sélectionner Expert DLL puis cliquer sur OK.

Vous venez de créer le projet contenant la DLL. Lisez attentivement le commentaire. Il vous importe de choisir si oui ou non vous décider de faire passer ou de renvoyer des string de votre DLL. Il me semble qu’il ne vaut mieux jamais utiliser cette possibilité. Il est préférable de n’utiliser que les PChar pour des raisons de compatibilités et d’évolutivité de votre programme sur les différentes plateformes et versions de Microsoft Windows ©.

Finalement, enregistrer votre Projet DLL sous le nom : « DLLObjet.dpr ».

I-B - Écriture de l’objet

Créez une nouvelle unité qui contiendra l’objet et enregistrez-la sous le nom de « DefObjet.pas ».

Puis définissez l’objet suivant (l’unité entière est recopiée ci-dessous afin de faciliter la compréhension) :

1. unit DefObjet;

2. interface

3. uses SysUtils;

4. type

5. TObjetExemple = class

6. private

7. FX : Double;

8. public

9. procedure WX(const Value: Double); virtual; export; // Écriture de X

10. function ReadX : Double; virtual; export; // Lecture de X

11. function Carre : Double; virtual; export; // Calcul du Carre de X

12. end;

13. function GetObjetExemple : TObjetExemple;

14. // Cette fonction permet de créer et de renvoyer une instance de l’objet TobjetExemple.

15. implementation

16. { TObjetExemple }

17. function GetObjetExemple : TObjetExemple; export;

18. begin

19. result := TObjetExemple.Create;

20. end;

21. //-------------------------------------------------------------------------------------------

22. function TObjetExemple.Carre: Double; export;

23. begin

24. result := sqr(FX);

25. end;

26. //-------------------------------------------------------------------------------------------

27. function TObjetExemple.ReadX: Double; export;

28. begin

29. result := FX;

30. end;

31. //-------------------------------------------------------------------------------------------

32. procedure TObjetExemple.WX(const Value: Double); export;

33. begin

34. if Value > 0 then

35. FX := Value

36. else

37. raise exception.Create('X must be 0');

38. end;

39. end.

Remarquez la présence de la clause export à la fin de la déclaration des fonctions.

I-C - Écriture du code source du projet de la DLL

Il faut à présent terminer l’exportation des fonctions de la DLL vers les autres programmes. Pour cela, retournez à votre source du projet (fichier DLLObjet.dpr) et déclarez dans la clause exports la fonction GetObjetExemple.

Votre source du projet doit ressembler à ceci :

1. library DLLObjet;

2. uses

3. SysUtils,

4. Classes,

5. DefObjet in 'DefObjet.pas';

6. {$R *.res}

7. exports

8. GetObjetExemple;

9. begin

10. end.

Finalement, compilez votre DLL. Dans le répertoire où vous avez enregistré votre projet se trouve le fichier compilé « DLLObjet.DLL » que nous allons utiliser depuis une application externe.

II - Écriture de l’application utilisant la DLL

II-A - Création d’un nouveau projet

Cliquez sur le menu Fichier, puis Nouveau et enfin Application :

Enregistrez votre projet sous le nom « UseObjetDDL.dpr » et l’unit1 sous le nom de « WinMain.pas ».

Créez une nouvelle unité et enregistrez-la sous le nom de « ImportObjetDLL.pas ».

Cette unité va servir à l’importation de la DLL.

II-B - Écriture de l’unité d’importation de l’objet

Copiez-collez la déclaration de l’objet écrite dans la partie interface de l’unité DefObjet.pas de la DLL dans la nouvelle unité ImportObjetDLL.pas. Remplacez les mots-clés export par abstract ce qui permet de ne pas avoir à réécrire l’implémentation de l’objet.

Enfin, il reste à déclarer comme fonction externe la fonction GetObjetExemple de l’unité DefObjet.pas de la manière qui suit :

function GetObjetExemple : TObjetExemple; external 'DLLObjet.dll';

dans la partie interface de ImportObjetDLL.

L’unité ImportObjetDLL.pas doit donc ressembler à ceci :

1. unit ImportObjetDLL;

2. interface

3. type

4. TObjetExemple = class

5. private

6. FX : Double;

7. public

8. procedure WX(const Value: Double); virtual; abstract;

9. function ReadX : Double; virtual; abstract;

10. function Carre : Double; virtual; abstract;

11. end;

12. function GetObjetExemple : TObjetExemple; external 'DLLObjet.dll';

13. implementation

14. { TObjetExemple }

15. end.

« External ‘DLLObjet.dll’ » signifie que le liage de la DLL est statique. La DLL doit se trouver soit dans le répertoire du programme qui l’utilise soit dans l’un des répertoires clés de votre ordinateur (Windows ou Windows\System par exemple).

II-C - Utilisation de l’objet

Il ne nous reste plus qu’à utiliser l’objet. Sur la form1, apposez deux TEdits et un TButton :

Dans la partie implémentation de l’unité WinMain, déclarez dans les uses l’unité ImportObjetDLL.

Puis sur l’évènement OnClic du Button utiliser l’objet en le créant à l’aide de la méthode de la DLL GetObjetExemble. Finalement, l’unité WinMain ressemble à :

1. unit WinMain;

2. interface

3. uses

4. Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

5. Dialogs, StdCtrls;

6. type

7. TForm1 = class(TForm)

8. Button1: TButton;

9. Edit1: TEdit;

10. Edit2: TEdit;

11. procedure Button1Click(Sender: TObject);

12. private

13. { Déclarations privées }

14. public

15. { Déclarations publiques }

16. end;

17. var

18. Form1: TForm1;

19. implementation

20. uses ImportObjetDLL;

21. {$R *.dfm}

22. procedure TForm1.Button1Click(Sender: TObject);

23. var Ob : TObjetExemple;

24. begin

25. Ob := GetObjetExemple; // Création de l’objet

26. try

27. Ob.WX(StrToFloat(Edit1.Text));

28. Edit2.Text := FloatToStr(OB.Carre);

29. finally

30. Ob.Free; // Libération

31. end;

32. end;

33. end.

C’est à vous de tester votre premier programme liant un objet dans une DLL externe.

III - Conclusion

Ce bref article a été développé dans un souci pédagogique avec un objet très simple. La construction d’objets plus complexes posera sans nul doute des difficultés, notamment lorsque l’objet est visuel tel qu’une TForm auquel cas, il faudra récupérer le Handle de la Form. Le développeur débutant pourra se référer à d’autres articles du site www.developpez.com et trouvera de l’aide auprès de la communauté française sur le forum nzn.fr.delphi que l’on trouve facilement en naviguant sur le site http://www.vienneinfo.org/.
Enfin, avant de tout écrire au sein des DLL, essayez de vous documenter sur les objets COM. Cette technologie et ses dérivées constituent une véritable révolution de l’informatique même si, malheureusement, son apprentissage et sa maîtrise sont longs et difficiles.