Komplettes Projekt in DLL auslagern

[SirThornberry]

für mich klingeln die Fehler als wären Strings oder Objekte zwischen DLL und Haupprogramm ohne ShareMem ausgetauscht worden.

[GuenterS]

Zitat von SirThornberry:

für mich klingeln die Fehler als wären Strings oder Objekte zwischen DLL und Haupprogramm ohne ShareMem ausgetauscht worden.

ist dies auch der Fall, wenn man zwischen Hauptprogramm und DLL nur Shortstrings also strings[255] verwendet?

[Balu der Bär]

Nein, auch mit eingebundener ShareMem bleiben die bösen Fehler am Ende.

[Elvis]

Zitat von Balu der Bär:

Nein, auch mit eingebundener ShareMem bleiben die bösen Fehler am Ende.

Im Gegensatz zu Packages sind DLLs eigenständige Binaries. Sie enthalten also ihre eigene Implementierung eines MemoryManagers[1] und wenn nicht anders angegeben enthalten sie ihre eigene Version der RTL, aller verwendeten Unit und eigentlich allem was Delphi zu Delphi macht.
Wenn du ein Form aus einer DLL lädst hast du 3 Möglichkeiten.

• Du referenzierst die benötigten Packages (RTL,VCL,XXX) in Exe und DLL extern. Dadurch ist ein TObject für Echse und DLL das gleiche. Genau wie TObject und alles andere in den extern gelinkten Packages.
  Das bedeutet aber, dass du die DLL immer mit der gleichen Compilerversion wie bei der Echse kompilieren musst.
• Du benutzt Interfaces.
  Damit bist du kompatibel zwischen Sprachen und Delphi Versionen, da sich Interfaces in Delphi generell an COM-Pflichten halten und somit zwangläufig kompatibel sind.
  Du kannst damit auch easy die Abhängigkeit auf ShareMem los werden. Indem du anstatt Strings, WideStrings nimmst.
  WideString werden von Windows selbst verwaltet.
  IMHO sind Interfaces in Delphi32 fast immer die netteste Art Funktionalität bereit zu stellen.
  Dank autom. Referenzzählung muss sich der konsumierende Code auch nicht mehr mit widerlichen try-finally Blöcken ärgern.
• Du gibst nur ein Handle auf dein Fenster zurück und arbeitest nur mit API-Funktionen.
  Dadurch gibt es keine Vermischung von unterschiedlichen Implementierungen der RTL.

Verion1 ist die, die am einfachten ist. Aber sie zwingt dich mindestens RTL und VCL extern mitzugeben.
Lösung 2 erfordert einen Wrapper, der ein Interface implementiert. Aber nach diesem Mini-Schnipsel bist absolut unabhängig und kannst auch D7 kompilierte DLLs mit 2006 benutzen und vice versa.
Lösung 3 ist IMHO absolut furchtbar, auch wenn die WinAPI-Fritzen da sicherlich anderer Meinung wären.





[1]den Punkt hast du mit ShareMem schon gelöst

[GuenterS]

Kannst Du mir ein Beispiel geben wie, so ein Wrapper aussehen könnte?

Die DLL wurde mit D7 Prof. erstellt und sollte dann in TDE verwendet werden...

[Elvis]

Zitat von GuenterS:

Kannst Du mir ein Beispiel geben wie, so ein Wrapper aussehen könnte?

Die DLL wurde mit D7 Prof. erstellt und sollte dann in TDE verwendet werden...

Kein Problem.
Ich habe mich aber zurückgehalten, da ich keine Lust hatte mir was sinnvolles auszudenken.
Man nehme eine Form in D7, die Ein Edit, einen Button und eine ListBox hat.
Drücke ich den Button wird der Inhalt an die LB gehängt.
Das ganze könnte man so als Interface verpacken um diese Funktionalität anderen zur Verfügung zu stellen ohne dass sie etwas über TObject, AnsiStrings oder die VCL wissen müssten:

Delphi-Quellcode:

unit uDllFormInterfaces;

interface
uses
  Windows;

type
  IDllForm = interface(IUnknown)
  ['{CE9CD182-13A2-4DAE-B7AA-ED8A8100B8A4}']
    function get_Caption : WideString; stdcall;
    procedure set_Caption(const value : WideString); stdcall;

    function get_Item(aIndex : Integer) : WideString; stdcall;
    procedure set_Item(aIndex : Integer; const value : WideString); stdcall;

    function get_Handle : HWnd; stdcall;

    function AddLine(const line : WideString) : Integer; stdcall;

    procedure Show; stdcall;
    function ShowDialog : Integer; stdcall;
    procedure Hide; stdcall;


    property Caption : WideString
      read  get_Caption
      write set_Caption;
    property Item[aIndex : Integer] : WideString
      read  get_Item
      write set_Item;
    property Handle : HWnd
      read get_Handle;
  end;

Verpacken könnte man es so:

Delphi-Quellcode:

uses
  uDllFormInterfaces,
  uDllForm,
  Windows;

type
  TDllFormWrapper = class(TInterfacedObject, IDllForm)
  private
    fForm: TDllForm;
  protected
    function get_Caption: WideString; stdcall;
    function get_Item(aIndex: Integer): WideString; stdcall;
    procedure set_Caption(const value: WideString); stdcall;
    procedure set_Item(aIndex: Integer; const value: WideString); stdcall;
    property Form : TDllForm read fForm;
    function get_Handle: HWnd; stdcall;
  public

    function AddLine(const line: WideString): Integer; stdcall;

    property Caption : WideString
      read  get_Caption
      write set_Caption;
    property Item[aIndex : Integer] : WideString
      read  get_Item
      write set_Item;
    property Handle : HWnd
      read get_Handle;

    constructor Create;
    destructor Destroy; override;

    procedure Hide; stdcall;
    procedure Show; stdcall;
    function ShowDialog : Integer; stdcall;

  end;

  function CreateDllForm : IDllForm; stdcall;

implementation

uses
  Dialogs;

function CreateDllForm : IDllForm;
begin
  result := TDllFormWrapper.Create();
end;

{ TDllFormWrapper }

constructor TDllFormWrapper.Create;
begin
  inherited;
  fForm := TDllForm.Create(nil);
end;

destructor TDllFormWrapper.Destroy;
begin
  fForm.Free();
  ShowMessage('freed!'); // weil manche nicht an RefCounting glauben ;-)
  inherited;
end;

function TDllFormWrapper.AddLine(const line: WideString): Integer;
begin
  result := Form.ListBox1.Items.Add(line);
end;

function TDllFormWrapper.get_Caption: WideString;
begin
  result := Form.Caption;
end;

function TDllFormWrapper.get_Item(aIndex: Integer): WideString;
begin
  result := Form.ListBox1.Items[aIndex];
end;

procedure TDllFormWrapper.set_Caption(const value: WideString);
begin
  Form.Caption := value;
end;

procedure TDllFormWrapper.set_Item(aIndex: Integer;
  const value: WideString);
begin
  Form.ListBox1.Items[aIndex] := value;
end;

procedure TDllFormWrapper.Hide;
begin
  Form.Hide();
end;

procedure TDllFormWrapper.Show;
begin
  Form.Show();
end;

function TDllFormWrapper.ShowDialog : Integer;
begin
  result := Form.ShowModal();
end;

function TDllFormWrapper.get_Handle: HWnd;
begin
  result := Form.Handle;
end;

Ich habe eine Screenie angehängt, der zeigt dass es geht und beide Mini-Projekte.

[Balu der Bär]

Danke dir Robert, mal gucken inwieweit ich das in meinem Programm umsetzen kann.