DLL Auslesen

[XXcD]

Hallo,
ich schreibe momentan an einem Programm dass durch DLL Datein erweitert werden kann.
Die DLLs sollen kleine Module sein.

Meine DLL sieht folgendermaßen aus(testdll.dll):

Delphi-Quellcode:

library testdll;

uses
  SysUtils,
  Classes,
  Forms;

  type
  TInformationen = class
    FVersion    : String;
    FName  : String;
    FDescription: string;
  end;

{$R *.res}

function DLLInformationen: TInformationen; stdcall;
var
Informationen: TInformationen;
begin
Informationen:= TInformationen.Create;
Informationen.FVersion:='1.0';
Informationen.FName:='First Modul';
Informationen.FDescription:='Kleine beschreibung';
Result:=Informationen;
end;

exports DLLInformationen;

begin
end.

Und so die Unit zum Auslesen der DLL(Modul_functions.pas):

Delphi-Quellcode:

uses
windows, SysUtils;

  type
  TInformationen = class
    private
    FVersion    : String;
    FName  : String;
    FDescription: string;
    FSettings: boolean;
    FVisible: boolean;
    public
    property Version: string read FVersion;
    property Name: string read FName;
    property Description: string read FDescription;
    property Settings: boolean read FSettings;
    property Visible: boolean read FVisible;
  end;

type
  TGetInformations = function: TInformationen; stdcall;
  function ModulInformationen: TInformationen;

implementation

function ModulInformationen: TInformationen;
var GetInformations: TGetInformations;
    Handle: THandle;
begin
  Handle:=LoadLibrary(PChar(ExtractFilePath(ParamStr(0))+'\Module\testdll.dll'));
  if Handle <> 0 then begin
    @GetInformations := GetProcAddress(Handle, 'DLLInformationen');
    if @GetInformations <> nil then begin
      result := GetInformations;
    end;
    FreeLibrary(Handle);
  end;
end;

end.

Und so der Aufruf in dem Formular:

Delphi-Quellcode:

uses
Modul_functions;
...
var
Informationen: TInformationen;
begin
Informationen:=ModulInformationen;
Showmessage(Informationen.Version+' | '+Informationen.Name);

Ich bin jetzt seit Stunden am suchen aber ich finde den Fehler einfach nicht.
Ich habe das genauso gemacht wie bei Delphi Treff in den TuTs

[quendolineDD]

Was denn für ein Fehler?
Edit: Und ich würde bei DLLs keine Klassen sondern Interfaces verwenden. Es gab bei Klassen doch irgend ein Problem, das durch die Verwendung unterschiedlicher Speichermanager da ein Problem geben kann (zum Beispiel mit der Klasse die deine DLL ausgibt, wird nirgendwo wieder freigegeben etc.)

[Apollonius]

Interessant. Die Klassendeklaration unterscheidet sich. Daneben: Warum steht beim Erstellen einer neuen DLL eigentlich immer dieser nette Kommentar in der dpr-Datei?

[XXcD]

Hier das Bild
http://img197.imageshack.us/img197/19/unbenanntkvk.jpg

Und kannst du mir da dann helfen wie die DLL genau aussehen muss?


Edit: Ich habe auch erst die DLL zur Laufzeit geöffnet zum testen.
Da funktionierte noch alles einwandfrei.
Und die Klasse hatte ich zu dem Zeitpunkt noch gleich das habe ich nur jetzt einmal geändert.

[XXcD]

Ich habe jetzt mal das gemacht was da in dem Kommentar steht:

testdll.dll

Delphi-Quellcode:

library testdll;

uses
  SysUtils,
  Classes,
  Forms;

  type
  TInformationen = class
    Version    : ShortString;
    Name  : ShortString;
    Description: ShortString;
    Settings: boolean;
    Visible: boolean;
  end;

{$R *.res}

function DLLInformationen: TInformationen; stdcall;
var
Informationen: TInformationen;
begin
Informationen:= TInformationen.Create;
Informationen.Version:='1.0';
Informationen.Name:='First Modul';
Informationen.Description:='Kleine beschreibung';
Informationen.Settings:=true;
Informationen.Visible:=true;
Result:=Informationen;
end;

exports DLLInformationen;

begin
end.

Auslesen:

Delphi-Quellcode:

interface

uses
windows, SysUtils;

  type
  TInformationen = class
    Version    : ShortString;
    Name  : ShortString;
    Description: ShortString;
    Settings: boolean;
    Visible: boolean;
  end;

type
  TGetInformations = function: TInformationen; stdcall;
  function ModulInformationen: TInformationen;

implementation

function ModulInformationen: TInformationen;
var GetInformations: TGetInformations;
    Handle: THandle;
begin
  Handle:=LoadLibrary(PChar(ExtractFilePath(ParamStr(0))+'\Module\testdll.dll'));
  if Handle <> 0 then begin
    @GetInformations := GetProcAddress(Handle, 'DLLInformationen');
    if @GetInformations <> nil then begin
      result := GetInformations;
    end;
    FreeLibrary(Handle);
  end;
end;

end.

Der Aufruf

Delphi-Quellcode:

Informationen:=ModulInformationen;
Showmessage(Informationen.Version+' | '+Informationen.Name);

Der Fehler bleibt aber der gleiche.

Wie kann ich denn Interfaces nutzen?

[himitsu]

Klassen lassen sich nicht einfach so über Modulgrenzen (EXE/DLL) hinweg nutzen,
da jedes Modul seine eigene RTTI hat und sich somit die Klassendefinitionen unterscheiden.

Strings sollte man auch nicht über Modulgrenzen hinweg verwenden,
oder man nutzt die Unit ShareMem.

Aber Letzeres steht auch in dem nettem Hinweistext der DLL.

[Apollonius]

Es ist nicht ratsam, die DLL wieder zu entladen und damit die Klasseninstanz freizugeben, bevor du sie dir überhaupt angesehen hast. :wink:

[XXcD]

Ok aber muüsste mehrere Daten in mein Programm kriegen.
Also die version, den Namen usw.

Ich könnte ja jetzt nacheinander jede Funktion einzeln aufrufen und immer den Rückgabewert von z.b. der version bekommen.
Aber das ist sicher nicht so eine tolle Lösung also muss irgendwie mit einem Aufruf alle Daten bekommen.
Dafür habe ich die Klasse erstellt.
Nur weiß ich nicht wie ich das anders machen soll.

[XXcD]

^^ Jo ohne FreeLibrary geht es jetzt aufeinmal. dann muss ich mal schauen, dass ich noch einen guten Zeitpunkt zum freigeben finde.
Vielen Dank.

[quendolineDD]

Anstatt Strings auszutauschen solltest du es so wie in der Win32Api machen. Zum einen gibt es dort Funktionen, die man erst aufrufen muss um zu wissen, wieviel Speicher allokiert werden muss, um die Funktion daraufhin ein zweites mal aufzurufen. Zum anderen gibt es Funktionen, welche als Parameter einen Pointer und als zweiten Parameter die Längenangabe der Variable verlangen.

Nutze lieber Interfaces, als das du ShareMem benutzt (meine persönliche Meinung).

[Apollonius]

Mit ShareMem hast du allerdings den Vorteil, dass du die DLL gleich wieder entladen kannst (sofern deine Klasse keine virtuellen Methoden haben).

[wicht]

Ich hoffe ich habe hier alles richtig verstanden, aber man könnte aus TInformationen doch auch einfach ein record machen? Sofern das am Ende den Anforderungen reicht...

[quendolineDD]

Wie gesagt. Mit Interfaces zu arbeiten finde ich an dieser Stelle am Besten. Auch da hier die Speicherverwaltung keine Probleme bereitet, da diese bei nicht-mehr-Verwendung freigegeben werden.
Mal für dich ein kleines Beispielprogramm, wie das aussehen könnte. Ist nur schnell zusammengetippt.

[himitsu]

Zitat:

Zitat von quendolineDD

Auch da hier die Speicherverwaltung keine Probleme bereitet, ...

Man sollte dann dennoch aufpassen, daß keine AnsiStrings, Strings, UnicodeStrings (ab D09), dynamische Arrays oder Objekte im Interface (also in Properties oder als Parameter bzw. Result) verbaut werden.
(vorallem nicht, wenn kein Shared-MemoryManager verwendet wird)

[quendolineDD]

Stimmt. War dann doch zu schnell getippt. Deswegen geben die Funktionen ja PChar zurück, intern wird aber mit Strings gearbeitet. Weiß nicht, ob das interne ein Dilemma darstellt.