FMX und VCL verbinden

[Minz3]

Huhu Gemeinde!

Ich probiere seit einigen Tagen diverse Möglichkeiten durch, um innerhalb einer VCL Anwendung FireMonkey zum laufen zu bringen. Letztendlich bin über Stephen Ball und später über Harry Stahl auf die Methode der Einbindung via DLL Files gekommen. Das Prinzip klingt gut nur an der Umsetzung hapert es.
Ich schaffe es immer wieder eine access violation zu erzeugen (Screenshot im Anhang).

Hoffentlich habe ich an alles gedacht, sodass ihr euch ein gutes Bild machen könnt. Ziel ist es wie gesagt für mich im ersten Schritt aus dem VCL Formular das FMX Formular zu öffnen. Vielleicht bin ich da schon irgendwie auf dem falschen Dampfer. ^^

Ich danke euch schon mal für alle Vorschläge und Hinweise. :)

Die Ordner-Struktur meines Projekts sieht so aus:

Projektpfad
C:\Users\USERNAME\Documents\Embarcadero\Studio\Pro jekte\Neuer Ordner
Debugpfad (inklusive exe und DLL)
C:\Users\USERNAME\Documents\Embarcadero\Studio\Pro jekte\Neuer Ordner\Win32\Debug

Die DLL ist ganz wie im Beispiel von Harry Stahl aufgebaut:

Delphi-Quellcode:

library ProjectDLL;

uses
  System.SysUtils,
  System.Classes,
  FMX.Forms,
  Unit1FMX in 'Unit1FMX.pas' {Form1};

{$R *.res}

exports
  TestFunc;

begin
end.

Die FMX Form beinhaltet lediglich nur ungenutzte Elemente, damit es nicht ganz so leer ist. Die Funktion ist auch eher ein Dummy:

Delphi-Quellcode:

unit Unit1FMX;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.Filter,
  FMX.Effects, FMX.Filter.Effects, FMX.Surfaces, FMX.StdCtrls, FMX.Layouts,
  FMX.ExtCtrls, FMX.Controls.Presentation, FMX.Objects, FMX.Calendar;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    TrackBar1: TTrackBar;
    ImageViewer1: TImageViewer;
    Label1: TLabel;
    Calendar1: TCalendar;
    CalloutRectangle1: TCalloutRectangle;
  private
    { Private-Deklarationen }

  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

function testfunc : Boolean; export;

implementation

{$R *.fmx}

function testfunc : Boolean;
begin
  result := false;
end;

end.

Jetzt kommen wir zur VCL Form. Ich werde mich hier auf die wesentlichen Funktionen beschränken:

Delphi-Quellcode:

{...Unit, Interface, Uses, TForm1...}

type
  TTestFunc = function : Boolean;

var
  Form1: TForm1;
  TestFunc: TTestFunc = nil;
  DllHandle: THandle;

implementation

{$R *.dfm}
{...Funktionen...}
procedure TForm1.Button2Click(Sender: TObject);
begin
  TestFunc;
end;

{...Funktionen...}

initialization
  if DllHandle = 0 then begin
    DllHandle := LoadLibrary('ProjectDLL.dll');
    if DllHandle > 0 then begin
     @TestFunc := GetProcAddress(DllHandle,
       'TestFunc');
    End else begin
      MessageDlg('TestFunc steht nicht zur Verfügung',
        mtInformation, [mbOK], 0);
    end;
end;

finalization
if DLLHandle <> 0 then
  FreeLibrary(DLLHandle);

end.

[DeddyH]

Und bei

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
begin
  if Assigned(TestFunc) then
    TestFunc;
end;

:?:

[Minz3]

Ok es crasht nicht mehr. Worauf genau prüft "Assigned"?

Beim Debuggen fiel mir noch auf, dass an der Stelle:

Delphi-Quellcode:

initialization
  if DllHandle = 0 then begin
    DllHandle := LoadLibrary('ProjectDLL.dll');
    if DllHandle > 0 then begin
     @TestFunc := GetProcAddress(DllHandle,
       'TestFunc');
    End else begin
      MessageDlg('TestFunc steht nicht zur Verfügung',
        mtInformation, [mbOK], 0);
    end;
end;

GetProcAddress = nil zurückgibt.

Das kann doch eigentlich nicht sein, wenn der DllHandle richig überschrieben wurde, oder doch? An der Stelle LoadLibrary kriegt das DllHandle auch einen plausiblen Wert zugewiesen.

[NormanNG]

Hi,

verwende überall die gleiche Schreibweise...

Delphi-Quellcode:

function testfunc...


exports
  TestFunc;

[Minz3]

Zitat:

Zitat von NormanNG (Beitrag 1446886)

Hi,

verwende überall die gleiche Schreibweise...

Delphi-Quellcode:

function testfunc...


exports
  TestFunc;

Hab ich mal geändert. Ist mir nicht aufgefallen, danke dafür. Allerdings bringt mich das nicht wirklich weiter.^^

[Rolf Frei]

Wenn ich da nichts übersehe, machst du da einen Pointer auf nil. TestFunc ist mit nil initialisiert und so führt @nil zu einer Access Violation. Also einfach das @ entfernen und es sollte gehen.

TestFunc := GetProcAddress(DllHandle, 'TestFunc');

Warum importierst du die Funktion nicht einfach wie folgt. So brauchst du das ganze Load/FreeLibrary Zeugs nicht. Deine DLL muss ja eh immer vorhanden sein. Also macht es keinen Sinn, diese zur Runtime als Latebinding zu laden. Mit dieser Art der DLL Einbindung, wird die DLL automatisch beim Programmstart geladen. Ist also deutlich einfacher.

Delphi-Quellcode:

{...Unit, Interface, Uses, TForm1...}

function TestFunc(): Boolean; 

var
  Form1: TForm1;
  DllHandle: THandle;

implementation

{$R *.dfm}
{...Funktionen...}


procedure TForm1.Button2Click(Sender: TObject);
begin
  TestFunc;
end;

{...Funktionen...}
function TestFunc; external 'ProjectDLL.dll' name 'TestFunc';

{ Das brauchst du in diesem Fall nicht, da die DLL durch die obige Deklaration automatisch beim Programmstart geladen wird.
initialization
  if DllHandle = 0 then begin
    DllHandle := LoadLibrary('ProjectDLL.dll');
    if DllHandle <= 0 then begin
      MessageDlg('ProjectDLL.dll steht nicht zur Verfügung',
        mtInformation, [mbOK], 0);
    end;
end;

finalization
if DLLHandle <> 0 then
  FreeLibrary(DLLHandle);
}

end.

Lies dir mal in der Hilfe die Beschreibung zu "external": http://docwiki.embarcadero.com/RADSt...tions_(Delphi)

[Minz3]

Ich hab das mal getestet, mir wird die Funktion "TestFunc" jetzt als überladen angezeigt. Dies scheint mir aber nicht so plausibel zu sein, da keine Parameter übergeben werden. Es kommt lediglich ein boolscher Wert zurück.

Ich habe mich auch nebenbei an dem Hydra Framework probiert. Das wäre aber ein anderes Thema. Dort verzweifel ich ähnlich wie hier. ^^

[DasWolf]

Zitat:

Zitat von Minz3 (Beitrag 1447075)

Es kommt lediglich ein boolscher Wert zurück.

Vielleicht deswegen?

Delphi-Quellcode:

function testfunc : Boolean;
begin
  result := false;
end;

[Rolf Frei]

Zitat:

Zitat von Minz3 (Beitrag 1447075)

Ich hab das mal getestet, mir wird die Funktion "TestFunc" jetzt als überladen angezeigt. Dies scheint mir aber nicht so plausibel zu sein, da keine Parameter übergeben werden. Es kommt lediglich ein boolscher Wert zurück.

Ich habe mich auch nebenbei an dem Hydra Framework probiert. Das wäre aber ein anderes Thema. Dort verzweifel ich ähnlich wie hier. ^^

Ähm, das ist ja genau das was deine Funktion in der DLL macht. Sie liefert den Boolean Wert "False" retour. Funktioniert also alles wie erwartet.

Betreffs dem "überladen" hast du wohl nun diese Funktion 2x in deinem Code. Poste mal deinen aktuellen Quellcode, wenn du es nicht selber siehst. Mach am besten eine eigene Unit mit den ganzen Funktionen/Proceduren der DLL und dann hast im Interface die Definitionen und im der Implementation die Verbindung zu externen DLL. Also in etwa so:

Delphi-Quellcode:

unit ProjectDLLInterface;

interface

function TestFunc: Boolean;
procedure ShowMyFMXForm();

implementation

function TestFunc: Boolean; external 'ProjectDLL.dll' name 'TestFunc';
procedure ShowMyFMXForm(); external 'ProjectDLL.dll' name 'ShowMyFMXForm';

end.

[Minz3]

Puh also für mich wird's langsam schon unübersichtlich.

Zitat:

Ähm, das ist ja genau das was deine Funktion in der DLL macht. Sie liefert den Boolean Wert "False" retour. Funktioniert also alles wie erwartet.

Tatsächlich tut sie dahingehend das, was sie soll. Habe jetzt eine procedure geschrieben, welche nur das FMX Formular aufruft, um mal weg von der function zu kommen.

Zitat:

Betreffs dem "überladen" hast du wohl nun diese Funktion 2x in deinem Code. Poste mal deinen aktuellen Quellcode, wenn du es nicht selber siehst. Mach am besten eine eigene Unit mit den ganzen Funktionen/Proceduren der DLL und dann hast im Interface die Definitionen und im der Implementation die Verbindung zu externen DLL.

Cool das du das ansprichst! Das habe ich in dem einen Tutorial auch gesehen, aber nicht ganz verstanden, warum man das so machen sollte. Ich sehe da keinen wirklichen Vorteil. Dient das "nur" zur Übersicht oder ist es damit einfach besserer zu arbeiten? An der Umsetzung sitze ich jetzt, bis dahin hänge ich mal den aktuellen QuellCode ran.

DLL:

Delphi-Quellcode:

library ProjectDLL;

uses
  System.SysUtils,
  System.Classes,
  FMX.Forms,
  Unit1FMX in 'Unit1FMX.pas' {FMXForm1};

{$R *.res}

exports
  //TestFunc,
  TestProc;

begin
end.

FMX:

Delphi-Quellcode:

unit Unit1FMX;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.Filter,
  FMX.Effects, FMX.Filter.Effects, FMX.Surfaces, FMX.StdCtrls, FMX.Layouts,
  FMX.ExtCtrls, FMX.Controls.Presentation, FMX.Objects, FMX.Calendar;

type
  TFMXForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    TrackBar1: TTrackBar;
    ImageViewer1: TImageViewer;
    Label1: TLabel;
    Calendar1: TCalendar;
    CalloutRectangle1: TCalloutRectangle;
  private
    { Private-Deklarationen }

  public
    { Public-Deklarationen }
  end;

var
  FMXForm1: TFMXForm1;

function TestFunc : Boolean; export;
procedure TestProc; export;

implementation

{$R *.fmx}

procedure TestProc;
begin
  FMXForm1.Show;
end;

function testfunc : Boolean;
begin

  result := false;

end;

end.

Main Unit:

Delphi-Quellcode:

unit UnitMain;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes,
  Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Data.DB, Data.Win.ADODB,
  Vcl.StdCtrls, Vcl.ExtCtrls, Datasnap.DBClient, Vcl.Grids, Vcl.DBGrids, Vcl.Mask,
  Vcl.DBCtrls, Datasnap.Provider, UnitDBM, UnitRB;

type
  TForm1 = class(TForm)
    DBGrid2: TDBGrid;
    Panel1: TPanel;
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    Button1: TButton;
    DBEdit1: TDBEdit;
    DBEdit2: TDBEdit;
    DBEdit3: TDBEdit;
    DBEdit4: TDBEdit;
    Button2: TButton;
    TOPcount: TEdit;
    Label4: TLabel;
    Panel2: TPanel;
    procedure Button1Click(Sender: TObject);
    procedure DBGrid2DblClick(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

type
  TTestFunc = function : Boolean;
  TTestProc = procedure;

var
  Form1: TForm1;
  //TestFunc: TTestFunc = nil;
  //TestProc: TTestProc;
  DllHandle: THandle;

implementation

{$R *.dfm}

function TestFunc : Boolean; external 'ProjectDLL.dll' name 'TestFunc';
procedure TestProc; external 'ProjectDLL.dll' name 'TestFunc';

procedure TForm1.Button2Click(Sender: TObject);
begin
  TestProc;
end;

procedure TForm1.DBGrid2DblClick(Sender: TObject);
begin
  {with UnitDBM.Form2 do
    ShowMessage(ClientDataSet1.FieldByName('payment_date').AsString);}
end;

{initialization
  if DllHandle = 0 then begin
    DllHandle := LoadLibrary('ProjectDLL.dll');
    if DllHandle > 0 then begin
      //@TestFunc := GetProcAddress(DllHandle, 'TestFunc');
      DllHandle := LoadLibrary('ProjectDLL.dll');
    End else begin
      MessageDlg('ProjectDLL.dll steht nicht zur Verfügung', mtInformation, [mbOK], 0);
    end;
end;

finalization
if DLLHandle <> 0 then
  FreeLibrary(DLLHandle);}
end.

ProjectDLLInterface

Delphi-Quellcode:

unit ProjectDLLInterface;

interface

procedure TestProc;

implementation

function TestFunc : Boolean; external 'ProjectDLL.dll' name 'TestProc';
procedure TestProc; external 'ProjectDLL.dll' name 'TestProc';

end.

So für zwischendurch: Danke euch für die Hilfe! Ich konnte schon einiges lernen. :)

[Minz3]

Noch eine Frage zum Verständnis:

Die Art und Weise, wie das ganze funktioniert ist doch folgende:

Die Main Unit beinhaltet die VCL Form und die Grundfunktionen, die FMX Unit beinhaltet die FMX Form und FireMonkey Funktionen. Die FMX Unit gibt die Prozeduren und Funktionen über den Befehl

Delphi-Quellcode:

procedure TestProc; export;

an die DLL frei.

In der DLL befinden sich die Informationen, auf welche Unit zugegriffen wird (für die Quellfunktionen) und welche Funktionen/Prozeduren exportiert werden.

In der Main Unit werden dann die Funktionen mit Hilfe der DLL geladen und aufgerufen. Entweder per Initialisierung oder als Funktionsdeklaration.

Delphi-Quellcode:

initialization
  if DllHandle = 0 then begin
    DllHandle := LoadLibrary('ProjectDLL.dll');
    if DllHandle > 0 then begin
      //@TestFunc := GetProcAddress(DllHandle, 'TestFunc');
      DllHandle := LoadLibrary('ProjectDLL.dll');
    End else begin
      MessageDlg('ProjectDLL.dll steht nicht zur Verfügung', mtInformation, [mbOK], 0);
    end;
end;

finalization
if DLLHandle <> 0 then
  FreeLibrary(DLLHandle);

Delphi-Quellcode:

procedure TestProc; external 'ProjectDLL.dll' name 'TestProc';

An welcher Stelle kommt dann die "ProjectDLLInterface" Unit von Rolf zum Einsatz?

Habe ich das so richtig verstanden oder hab ich was falsch wiedergegeben?

[Minz3]

Kleines Update:
Ich teste ja fleißig und probiere verschiedene Methoden.

Mir ist aufgefallen, dass bei den beiden Zugriffsmöglichkeiten auf die DLL bei verschiedenen Adressen die Zugriffsverletzung eintritt.

Bei der ersten Variante über

Delphi-Quellcode:

initialization
  if DllHandle = 0 then begin
    DllHandle := LoadLibrary('ProjectDLL.dll');
    if DllHandle > 0 then begin
      TestProc := GetProcAddress(DllHandle, 'TestProc');
      DllHandle := LoadLibrary('ProjectDLL.dll');
    End else begin
      MessageDlg('ProjectDLL.dll steht nicht zur Verfügung', mtInformation, [mbOK], 0);
    end;
end;

finalization
if DLLHandle <> 0 then
  FreeLibrary(DLLHandle)

kommt der Fehler:
"Zugriffsverletzung bei Adresse 047E30E3 in Modul 'ProjectDLL.dll'. Lesen von Adresse 000000B0"

Während bei der Methode:

Delphi-Quellcode:

procedure TestProc; external 'ProjectDLL.dll' name 'TestProc';

die Meldung:
"Zugriffsverletzung bei Adresse 02A630E3 in Modul 'ProjectDLL.dll'. Lesen von Adresse 000000B0"
kommt.

[DeddyH]

Du solltest das Formular in der DLL vielleicht besser erst einmal erzeugen, bevor Du es anzeigst.

[Minz3]

Zitat:

Zitat von DeddyH (Beitrag 1447540)

Du solltest das Formular in der DLL vielleicht besser erst einmal erzeugen, bevor Du es anzeigst.

Hoffe das hab ich richtig umgesetzt (bin ja noch Neuling im Umgang mit DLL Files)

Unit1FMX.pas (befindet sich im DLL Projekt)

Delphi-Quellcode:

procedure TestProc;
begin
  FMXForm1 := TFMXForm1.Create(Application);
  FMXForm1.ShowModal;
end;

Ich vermute aber, dass ich da einen Fehler gemacht habe. :pale:

[DeddyH]

Versuch es mal so (die globale Variable kannst Du eigentlich löschen):

Delphi-Quellcode:

procedure TestProc;
var
  frm: TFMXForm1;
begin
  frm := TFMXForm1.Create(nil);
  try
    frm.ShowModal;
  finally
    frm.Free;
  end;
end;

[Minz3]

Nope das hat leider auch nicht geholfen, sieht aber auf jeden Fall richtiger aus.

Ich habe die Vermutung, dass der Fehler weiter vorne liegen muss, also habe ich den Zugriff auf die DLL vielleicht nicht richtig umgesetzt.

[DeddyH]

Zitat:

Delphi-Quellcode:

initialization
  if DllHandle = 0 then begin
    DllHandle := LoadLibrary('ProjectDLL.dll');
    if DllHandle > 0 then begin
      TestProc := GetProcAddress(DllHandle, 'TestProc');
      // Wozu denn das?
      DllHandle := LoadLibrary('ProjectDLL.dll');
    End else begin
      MessageDlg('ProjectDLL.dll steht nicht zur Verfügung', mtInformation, [mbOK], 0);
    end;
end;

Wieso lädst Du die DLL noch einmal, wenn sie bereits erfolgreich geladen wurde?

[Minz3]

Da hab ich gepennt. Danke für den Hinweis! Der Schritt ist natürlich überflüssig.