Event aus BPL absetzen

[Helmi]

Hallo,

wenn ich eine Procedure bzw. Function in einer BPL aufrufen möchte, dann geht das ja mit GetProcAddress

Wie kann ich aber aus einer BPL raus ein Event absetzen?

[Helmi]

*hochschieb*

[Helmi]

kann mir keiner weiterhelfen?

[jaenicke]

Ich würde das genauso machen wie bei einer DLL: Mit einem Interface.
Sprich ich gebe der DLL oder BPL über eine Funktion das Interface und auf der anderen Seite werden dann alle registrierten Interfaces durchlaufen und eine darin enthaltene Ereignismethode aufgerufen.

[Helmi]

Gibt's dafür ein Beispiel?
Hab mit Interfaces direkt noch keine Erfahrungen

[jaenicke]

In der Anwendung:

Delphi-Quellcode:

type
  IHostInterface = interface
    function GetOnShutdown: TList<IDLLClient>;
  end;

  IDllHostInterface = interface
    procedure Shutdown;
  end;

  THostInterface = class(TInterfacedObject, IHostInterface, IDllHostInterface)
  private
    FOnShutdown: IInterfacedList<IDLLClient>;
    function GetOnShutdown: IInterfacedList<IDLLClient>;
  public
    proedure Shutdown; // führt Shutdown in allen registrierten DLL-Clients aus
    property OnShutdown: IInterfacedList<IDLLClient> read GetOnShutdown;
  end;

In der DLL:

Delphi-Quellcode:

type
  IDLLClient = interface
    procedure Shutdown;
  end;

  TDllClient = class(TInterfacedObject, IDllClient)
  public
    procedure Shutdown;
  end;

procedure InitDll(const AHost: IHostInterface);
var
  DllClient: TDllClient;
begin
  DllClient := TDllClient.Create;
  AHost.OnShutdown.Add(DllClient);
end;

exports
  InitDll;

Sprich du übergibst der DLL z.B. ein Interface, in dem ein Multicast-Event steckt. Wenn du nur eine DLL hast, reicht natürlich auch ein einfaches Interface statt der Liste. IInterfacedList ist eine Eigenimplementierung, die ich im Büro geschrieben habe, das gibt es bestimmt aber auch schon irgendwo (in Spring4D vielleicht?). Sonst kann man es ja schnell schreiben.

Das Shutdown-Event hat auch direkt einen Sinn. Wenn man die DLL-Interfaces in Events im Hostinterface hat und die DLLs die Hostinterfaces, werden die Interfaces durch die Gegenseitige Referenz nie freigegeben. Deshalb führe ich vor dem Beenden des Programms den Shutdown-Befehl aus, durch den in der DLL die Events wieder herausgenommen werden.
(Sauberer wäre die DLL Klasse im Programm in eine Eventklasse und eine Klasse mit den registrierten DLLs zu trennen... aber das wird hier als Beispiel zu umfangreich...)

[Helmi]

sorry für meine späte Antwort - bin einfach nicht dazu gekommen...

Ich hab momentan das Problem, dass ich das nicht wirklich versteh.

Vielleicht mal kurz erklärt was ich vor hab/brauch/will:

Ich hab eine BPL, in der ich eine Klasse erzeuge (erzeugen in initialization, löschen in finalization)

Darin wird eine Komponente erzeugt, die Events hat.

Diese Events möchte ich durch meine Klasse an die Hostanwendung weiter geben.

[jaenicke]

Dann kannst du das ja genau so machen. Deine Hostanwendung übergibt ein Interface an die DLL und du hast in der DLL eine Klasse, die die Events empfängt und an dieses Interface weitergibt.

[Helmi]

muss ich mir von der Interface-Klasse eine Instanz erzeugen?

[jaenicke]

Ja. Bei Interfaces gibt es keinen Mechanismus wie Klassenmethoden oder so etwas.

[Helmi]

Hallo,

ich muss das Thema nochmal aufwärmen, da ich mich jetzt mal damit nochmal beschäftigt habe.

Anbei mein Test-Projekt - ich hab da irgendwie nen Knoten im Kopf bei der Verwendung/beim Verständnis von Interfaces.

Was will ich tun?
1. eine BPL laden (was funktioniert)
2. in der BPL eine Komponente erzeugen, die Events feuert (im Test ein einfacher Timer)
3. von der Hauptanwendung eine Procedure/Function in der BPL aufrufen (z. B. um den Timer zu starten)
4. wenn das Timer-Event gefeuert wird, dann soll diese in der Hauptanwendung aufschlagen

Momentan funktioniert leider weder Punkt 3 noch Punkt 4.

Bei Punkt 3 fehlt mir leider der Ansatz, bei Punkt 4 weiss ich leider nicht, warum ich keine ShowMessage sehe.
Das Event vom Timer müsste gefeuert werden und dann die Host-Procedure aufgerufen werden.

Vielleicht könnte ein Interface-Experte mal ein Auge drauf werfen - mir fehlt gerade der richtige Ansatz dafür

[jaenicke]

Ja, da ist ein Knoten, der hat aber nichts mit Interfaces zu tun. ;-)

Delphi-Quellcode:

    FOnTimer: TNotifyEvent;

    procedure SetOnTimer(Value: TNotifyEvent);
//...
    property OnTimer: TNotifyEvent read FOnTimer write SetOnTimer;
  end;

// ...

constructor TSPS.Create;
begin
  inherited Create;

  Timer := TTimer.Create(nil);
  Timer.OnTimer := OnTimer;

Du weist im Konstruktor den Wert von OnTimer, also FOnTimer als Ereignisbehandlung für OnTimer des Timers zu. Zu dem Zeitpunkt ist da allerdings nichts drin, deshalb wird der Timer nie gefeuert.

In SetOnTimer, also dem Setter der Property, rufst du wiederum die Interfacemethode auf. Aber der Setter wird ja nie ausgelöst, zudem hat das nichts mit den Timerevents zu tun.

Langer Rede kurzer Sinn:

Delphi-Quellcode:

  TSPS = class(TObject)
  private
    FTimer: TTimer;
    procedure TimerEvent(Sender: TObject);
  public
    constructor Create;
    destructor Destroy; override;
  end;

// Konstruktor
  FTimer := TTimer.Create(nil);
  FTimer.OnTimer := TimerEvent;
  FTimer.Enabled := True;
  FTimer.Interval := 2000;

// Eventbehandlung
procedure TSPS.TimerEvent(Sender: TObject);
begin
  BPLClient.Host.TimerEvent;
end;

[Helmi]

Zitat:

Zitat von jaenicke (Beitrag 1331656)

Ja, da ist ein Knoten, der hat aber nichts mit Interfaces zu tun. ;-)

Ich sollte doch die Kaffeesorte wechseln :-)

Danke für den Hinweis.
Jetzt kommt das Event sauber an die Hauptanwendung.

Nur beim Beenden der Anwendung erhalte ich eine Fehlermeldung:

Zitat:

---------------------------
Benachrichtigung über Debugger-Exception
---------------------------
Im Projekt Project4.exe ist eine Exception der Klasse EInvalidPointer mit der Meldung 'Ungültige Zeigeroperation' aufgetreten.
---------------------------
Anhalten Fortsetzen Hilfe
---------------------------

Kann das mit der Referenzzählung zu tun haben?

[jaenicke]

Ja. Das liegt vermutlich daran, dass du in der BPL noch Referenzen auf die Hauptanwendung offen hast oder umgekehrt. Das Thema hatten wir bei DLLs auch. Beim Beenden der Anwendung wird bei uns ein Shutdown ausgelöst, der alle Interfacereferenzen sauber wieder auflöst, bevor die DLL entladen wird.

Ganz so einfach ist das leider nicht immer, vor allem bei komplexeren Anwendungen...