DLLs erstellen, die VCL-Komponenten enthalten (C++)

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Packages und DLLs erstellen


Eine der Stärken von DLLs besteht darin, dass eine DLL, die mit einem bestimmten Entwicklungstool geschrieben wurde, häufig auch in Anwendungen genutzt werden kann, die mit einem anderen Entwicklungstool erstellt wurden. Wenn Ihre DLL VCL-Komponenten enthält (z. B. Formulare), die von der aufrufenden Anwendung verwendet werden, müssen Sie exportierte Schnittstellenroutinen bereitstellen, die den Standardkonventionen für das Aufrufen entsprechen. Außerdem gilt es, C++-Namenskonflikte zu vermeiden und von der aufrufenden Anwendung nicht zu erwarten, dass sie VCL-Bibliotheken unterstützt, damit sie funktioniert. Um VCL-Komponenten zu erstellen, die sich exportieren lassen, verwenden Sie Laufzeit-Packages. Weitere Informationen finden Sie unter Packages und Komponenten: Übersicht.

Angenommen Sie möchten ein DLL erstellen, die das folgende einfache Dialogfeld anzeigt:

CB6 DevelopersGuide EN img 4.png

Der Quelltext für die Dialogfeld-DLL lautet folgendermaßen:

// 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;
}

Der Quelltext in diesem Beispiel zeigt das Dialogfeld an und speichert den Wert true in dem private Datenelement returnValue, wenn die Schaltfläche "Yes" gedrückt wird. Andernfalls hat returnValue den Wert false. Die public Funktion GetReturnValue() ermittelt den aktuellen Wert von returnValue.

Um das Dialogfeld aufzurufen und festzustellen, welche Schaltfläche gedrückt wurde, ruft die aufrufende Anwendung die exportierte Funktion InvokeYesNoDialog() auf. Diese Funktion ist in DLLMAIN.H als exportierte Funktion deklariert, die die C-Bindung (um die C++-Namensverkürzung zu vermeiden) und die C-Standardaufrufkonvention verwendet. Die Funktion ist in DLLMAIN.CPP definiert.

Durch die Verwendung der C-Standardfunktion als Schnittstelle in die DLL kann jede aufrufende Anwendung unabhängig davon, ob sie mit RAD Studio erstellt wurde, die DLL verwenden. Die zur Unterstützung des Dialogfeldes erforderliche VCL-Funktionalität ist in der DLL selbst gelinkt und die aufrufende Anwendung muss nichts darüber wissen.

Beachten Sie, dass beim Erstellen einer DLL, die die VCL verwendet, die benötigten VCL-Komponenten in die DLL gelinkt werden. Dadurch ergibt sich ein bestimmter Überhang. Die Auswirkung dieses Überhangs auf die Gesamtgröße der Anwendung kann minimiert werden, indem mehrere Komponenten in einer DLL kombiniert werden, die nur eine Kopie der VCL-Unterstützungskomponenten benötigt.

Siehe auch