Écrire et utiliser un objet dans une DLL avec Delphi

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

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) :

unit DefObjet; 
interface
uses SysUtils;
type
 TObjetExemple = class
 private
 FX : Double;
 public
 procedure WX(const Value: Double); virtual; export; // Écriture de X
 function ReadX : Double; virtual; export; // Lecture de X
 function Carre : Double; virtual; export; // Calcul du Carre de X
 end;
function GetObjetExemple : TObjetExemple;
// Cette fonction permet de créer et de renvoyer une instance de l’objet TobjetExemple.
implementation
{ TObjetExemple }
function GetObjetExemple : TObjetExemple; export;
begin
 result := TObjetExemple.Create;
end;
//-------------------------------------------------------------------------------------------
function TObjetExemple.Carre: Double; export;
begin
 result := sqr(FX);
end;
//-------------------------------------------------------------------------------------------
function TObjetExemple.ReadX: Double; export;
begin
 result := FX;
end;
//-------------------------------------------------------------------------------------------
procedure TObjetExemple.WX(const Value: Double); export;
begin
 if Value > 0 then
 FX := Value
 else
 raise exception.Create('X must be 0');
end;
end.

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

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 :

library DLLObjet;
uses
 SysUtils,
 Classes,
 DefObjet in 'DefObjet.pas';
{$R *.res}
exports
 GetObjetExemple;
begin
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.

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.

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 :

unit ImportObjetDLL;
interface
type
 TObjetExemple = class
 private
 FX : Double;
 public
 procedure WX(const Value: Double); virtual; abstract;
 function ReadX : Double; virtual; abstract;
 function Carre : Double; virtual; abstract;
 end;
function GetObjetExemple : TObjetExemple; external 'DLLObjet.dll';
implementation
{ TObjetExemple }
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).

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 à :

unit WinMain;
interface
uses
 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
 Dialogs, StdCtrls;
type
 TForm1 = class(TForm)
 Button1: TButton;
 Edit1: TEdit;
 Edit2: TEdit;
 procedure Button1Click(Sender: TObject);
 private
 { Déclarations privées }
 public
 { Déclarations publiques }
 end;
var
 Form1: TForm1;
implementation
uses ImportObjetDLL;
{$R *.dfm}
procedure TForm1.Button1Click(Sender: TObject);
var Ob : TObjetExemple;
begin
 Ob := GetObjetExemple; // Création de l’objet
 try
 Ob.WX(StrToFloat(Edit1.Text));
 Edit2.Text := FloatToStr(OB.Carre);
 finally
 Ob.Free; // Libération
 end;
end;
end.

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