FMX und VCL verbinden

[NormanNG]

Hi,

verwende überall die gleiche Schreibweise...

Delphi-Quellcode:

function testfunc...


exports
  TestFunc;

[Minz3]

Zitat von NormanNG:

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 von Minz3:

Es kommt lediglich ein boolscher Wert zurück.

Vielleicht deswegen?

Delphi-Quellcode:

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

[Rolf Frei]

Zitat von 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. ^^

Ä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 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);

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?