DLL mehrfach im Programm verwenden

[moelski]

Moin !

Ich hät da mal gern ein Problem mit DLLs ... Und zwar nutzen wir MDI Fenster. In diesen Fenstern kommen Daten an und die werden über eine DLL ausgewertet. Nun kann man aber logischerweise mehrere MDI Fenster parallel halten und somit hat man auch mehrfach die DLL in Verwendung. Die DLL wird jeweils dynamisch in dem MDI Fenster per LoadLibrary eingebunden.

So bis hierher alles tutti - das funktioniert. Nun habe ich mich erdreistet in der DLL eine globale Variable zu definieren:

Delphi-Quellcode:

var LastTime   : TDateTime;

Diese Zeit wird verwendet um die Zeitdifferenz zwischen zwei Dateneingängen zu überprüfen.

Wenn ich nun aber 2 MDI Fenster auf die gleiche DLL los schicke, dann scheinen diese globalen Variablen von beiden MDI Fenstern genutzt zu werden, denn die Zeitdifferenzen passen aufmal überhaupt nimmer ... Auch ein Logging hat das bestätigt.

Nun ist es sicherlich schon mal falsch (so vermute ich mal) in der DLL globale Variblen zu "halten", oder? Das Problem ist allerdings, dass dort verschiedene DLLs zur Auswertung herangezogen werden können. Und jede DLL braucht so ihre eigenen Merker zur Auswertung. Wie mache ich dass denn nun?

Ich hatte ja eigentlich gedacht / gehofft das durch die Erstellung eines neuen MDI Fensters und die damit verbundene dynamische Neuverlinkung der DLL quasi eine neue Instanz der DLL erzeugt wird. Aber dem ist wohl nicht so ?! :gruebel:

[moelski]

Moin !

Auweia ... Eigentor geschossen, es sind wirklich die globalen Variablen.
Aber die Frage bleibt ... Wie kann ich denn am besten Merker pro Instanz speichern die ich eigentlich in der DLL brauche?

[SirThornberry]

Genau wie bei Objekten. da erzeugt man auch eine Instanz und arbeitet mit dieser. Entsprechend kannst du (wie es in der Windows-Api häufig der Fall ist) einfach eine Struktur übergeben die von der DLL gehandhabt wird.

Bsp. (außerhalb der DLL):

Delphi-Quellcode:

type
  TTolleStruktur = packed record
    [...]
  end;
  PTolleStruktur = ^TTolleStruktur;

var
  meineStruktur: TTolleStruktur;
begin
  dll_function_init(@meineStruktur);
  dll_machwas(@meineStruktur);
  [...]

also einfach jedem Funktionsaufruf wo bisher die gloable verwendet wurde entsprechende Struktur mitgeben.

Im übrigen hat man das Problem nicht nur bei DLLs sondern auch bei Objectorientierter Programmierung (wenn mehrere Instanzen auf die gleiche globale zugreifen) etc.
Und genau aus diesem Grund sind globale Variablen auch so verpönt.

[hoika]

Hallo,

tja, dir bleibt wohl nichts anderes übrig,
als die Variable in deinem MDI-Fesnter zu merken
und als Parameter an dei DLL Funktion zu übergeben.

Pro Prozess sind globale DLL-Variablen das,
wie der Name schon sagt, global.


Heiko

[moelski]

Moin !

@SirThornberry:
So werde ichs wohl tun müssen.

Danke !

[moelski]

Moin !

Ich habe mal eine Demoanwendung erstellt mit einer DLL. Die Aufrufe der DLL Methoden bekommen einen Zeiger mitgeliefert so wie es SirThornberry vorgeschlagen hat.

Das Konstrukt funktioniert sogar erstaunlich gut. Auch wenn ich die DLL mehrfach verwende klappt alles.

Ich wollte nur nochmal nachfragen ob an meinem Aufbau noch irgendwas nicht stimmt oder ob das ggf. noch anders löst. Möchte nur vermeiden da in neue Fallen zu tappen ... :wink:

Vor allem der Aufruf mit Formular aus der DLL raus ist für mich wichtig. Da würde mich mal interessieren ob das ein brauchbarer Weg ist. Funktionieren tut es jedenfalls prächtig :)


Und dann hät ich noch ne Randfrage zu meinem Type Konstrukt ...

Delphi-Quellcode:

type 
  TDeviceInfos = packed record
    Test  : String;
    Zahl  : Double;
    Datum : TDateTime;
    Memo  : TMemo;
  end;

Das muss ja sowohl in der EXE als auch in der DLL definiert sein. Nun brauchen wir aber nicht in jeder DLL den Zugriff z.B. auf das dort angegebene Memo. Wenn ich nun in der DLL das angebe:

Delphi-Quellcode:

type 
  TDeviceInfos = packed record
    Test  : String;
    Zahl  : Double;
    Datum : TDateTime;
  end;

und in der EXE alles beim alten belasse dann funktionieren die Zugriffe trotzdem. Man darf allerdings nur Elemente von unten her wegnehmen. Ich denke weil sonst die Längen und damit die Zugriffe auf die einzelnen Elemente über den Pointer nimmer passen.
Also wie gesagt, das geht, aber nu stell ich mir doch die Frage ... Ist sowas erlaubt? Oder anders gefragt ... Kann das irgendwann man zu ungeahnten Problemen führen?

[jfheins]

In Windows (und damit kann es ja mal nicht ganz schlecht sein, denn die Typen machen sich ja auch Gedanken)

ist es so gelöst, dass so eine Struktur am Anfang ein Byte/Word/Integer hat, in dem die Größe drinsteht.

Die Funktion kann jetzt in Abhängigkeit der Größe feststellen, welcher record das eigentlich ist.

Befüllt werden muss das Feld natürlich, etwa mit

Delphi-Quellcode:

var
  a: MyRec;
begin
  a.Size = sizeof(a)

;)

[moelski]

Moin Julius,

nun eine Größenabfrage habe ich in meinem Konstrukt gar nicht mit drin. Funktionieren tut es dennoch.
Die Frage ist nur ob das überhaupt so gemacht werden sollte so wie ich es gemacht habe.