Création de DLL contenant des composants VCL (C++)

De RAD Studio
Aller à : navigation, rechercher

Remonter à Création de packages et de DLL


L'un des avantages des DLL consiste à pouvoir utiliser une DLL créée avec un outil de développement dans une application utilisant un autre outil de développement. Si une DLL contient des composants VCL (par exemple, des fiches) devant être utilisés par l'application appelante, il est nécessaire de fournir des routines d'interface exportées utilisant les conventions d'appel standard, en évitant le substantypage C++ et sans exiger pour fonctionner que l'application appelante gère les bibliothèques VCL. Pour créer des composants VCL pouvant être exportés, utilisez les packages d'exécution. Pour plus d'informations, voir Utilisation des packages et des composants - Présentation.

Par exemple, vous voulez créer une DLL afin d'afficher une boîte de dialogue simple :

CB6 DevelopersGuide EN img 4.png

Voici le code de la DLL boîte de dialogue :

// DLLMAIN.H
// ---------------------------------------------------------------------
#ifndef dllMainH
#define dllMainH
// ---------------------------------------------------------------------
#include <Classes.hpp>
#include <vcl\Controls.hpp>
#include <vcl\StdCtrls.hpp>
#include <vcl\Forms.hpp>

// ---------------------------------------------------------------------
class TYesNoDialog : public TForm {
__published: // IDE-managed Components

	TLabel *LabelText;
	TButton *YesButton;
	TButton *NoButton;

	void __fastcall YesButtonClick(TObject *Sender);
	void __fastcall NoButtonClick(TObject *Sender);

private: // User declarations

	bool returnValue;

public: // User declarations

	virtual __fastcall TYesNoDialog(TComponent *Owner);
	bool __fastcall GetReturnValue();
};

// exported interface function
extern "C" __declspec(dllexport) bool InvokeYesNoDialog();
// ---------------------------------------------------------------------
extern TYesNoDialog *YesNoDialog;
// ---------------------------------------------------------------------
#endif
// DLLMAIN.CPP
// ---------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop
#include "dllMain.h"
// ---------------------------------------------------------------------
#pragma resource "*.dfm"
TYesNoDialog *YesNoDialog;

// ---------------------------------------------------------------------
__fastcall TYesNoDialog::TYesNoDialog(TComponent *Owner) : TForm(Owner) {
	returnValue = false;
}

// ---------------------------------------------------------------------
void __fastcall TYesNoDialog::YesButtonClick(TObject *Sender) {
	returnValue = true;
	Close();
}

// ---------------------------------------------------------------------
void __fastcall TYesNoDialog::NoButtonClick(TObject *Sender) {
	returnValue = false;
	Close();
}

// ---------------------------------------------------------------------
bool __fastcall TYesNoDialog::GetReturnValue() {
	return returnValue;
}

// ---------------------------------------------------------------------
// exported standard C++ interface function that calls into VCL
bool InvokeYesNoDialog() {
	bool returnValue;
	TYesNoDialog *YesNoDialog = new TYesNoDialog(NULL);
	YesNoDialog->ShowModal();
	returnValue = YesNoDialog->GetReturnValue();
	delete YesNoDialog;
	return returnValue;
}

Le code de cet exemple affiche la boîte de dialogue et enregistre la valeur true dans la donnée membre privée returnValue si le bouton "Oui" est choisi. Sinon, returnValue prend la valeur false. La fonction membre publique GetReturnValue() renvoie la valeur en cours de returnValue.

Pour appeler la boîte de dialogue et déterminer le bouton choisi, l'application appelante doit utiliser la fonction exportée InvokeYesNoDialog(). Cette fonction est déclarée dans DLLMAIN.H comme fonction exportée utilisant le lieur C (afin d'éviter le substantypage C++) et la convention d'appel standard C. La fonction est définie dans DLLMAIN.CPP.

L'utilisation d'une fonction C standard comme interface de la DLL permet à toute application appelante, créée ou non avec C++Builder, d'utiliser la DLL. Les fonctionnalités VCL nécessaires au fonctionnement de la boîte de dialogue sont liées dans la DLL elle-même sans que l'application appelante sache quoique ce soit de la VCL.

Remarque : Lors de la création d'une DLL utilisant la VCL, les composants VCL nécessaires sont liés dans la DLL, ce qui en augmente la taille. L'impact de cette augmentation sur la taille totale de l'application peut être réduite en combinant plusieurs composants dans une seule DLL qui ne nécessite qu'une seule copie des composants de gestion VCL.

Voir aussi