Interface aus DLL mit dynamischer Bindung - wann FreeLibrary aufrufen?

[DeddyH]

Hab ich gemacht, die Reihenfolge stimmt: zuerst werden die DLL-Objekte freigegeben, danach käme der FreeLibrary-Aufruf. Mittlerweile ist es genau andersherum als eingangs geschildert: wenn ein neuer DLL-Name zugewiesen wird, klappt ein Nullen des alten Objektes mit anschließendem FreeLibrary einwandfrei, nur im Destruktor nicht mehr. Das alles aber nur im echten Projekt, das Referenzbeispiel funktioniert ohne Murren.

[DeddyH]

So, zu Hause nochmal unter XE7 nachgebaut und schon den ersten Fehler gefunden (Verwendung von string statt Widestring). Aber auch hier klappt es nur, wenn ich das FreeLibrary auskommentiere. Ich habe den Verdacht, dass ich eine ganz entscheidende Kleinigkeit vergessen habe (das ist zugegebenermaßen mein allererster Versuch in dieser Richtung). Ich hänge meine Demo mal an, jemand mit mehr Erfahrung auf dem Gebiet sieht das evtl. sofort.

[SMO]

Delphi-Quellcode:

procedure TfrmMain.btnLoadClick(Sender: TObject);
type
  TLoadProc = procedure(out Person: IPerson); stdcall;
var
  DLLHandle: NativeUInt;
  PersonProc: TLoadProc;
  Person: IPerson;
  Item: TListItem;
begin
// ...
              while not Person.Eof do
                begin
                  Item := lvChildren.Items.Add;
                  Item.Caption := Person.Child.Name;
                  Item.SubItems.Add(DateToStr(Person.Child.Birthdate));
                  Person.Next;
// ...
    finally
      Person := nil;
      FreeLibrary(DLLHandle);
    end;
end;

Das Problem ist folgendes:
Person.Child liefert ein Interface (IChild). Das wird hier aber nicht in einer lokalen Variable gespeichert, sondern es wird gleich auf eine Eigenschaft zugegriffen (Name, Birthdate). Damit die automatische Referenzzählung funktioniert, muss Delphi aber trotzdem jede Interface-Instanz in einer unsichtbaren lokalen Variable speichern (hier also 2x IChild), die dann am Ende der Subroutine in einem impliziten "finally" Block freigegeben werden.
FreeLibrary wird aber vorher ausgeführt, d.h. es wird auf Ressourcen zugegriffen, die nicht mehr verfügbar sind. Daher die Zugriffsverletzung.

Lösung: Person.Child explizit in einer Variable speichern und die Referenz ebenfalls vor FreeLibrary freigeben.

Delphi-Quellcode:

procedure TfrmMain.btnLoadClick(Sender: TObject);
type
  TLoadProc = procedure(out Person: IPerson); stdcall;
var
  DLLHandle: NativeUInt;
  PersonProc: TLoadProc;
  Person: IPerson;
  Child: IChild;
  Item: TListItem;
begin
// ...
              while not Person.Eof do
                begin
                  Item := lvChildren.Items.Add;
                  Child := Person.Child;
                  Item.Caption := Child.Name;
                  Item.SubItems.Add(DateToStr(Child.Birthdate));
                  Person.Next;
// ...
    finally
      Person := nil;
      Child := nil;
      FreeLibrary(DLLHandle);
    end;
end;

Falls die DLL übrigens erkennen soll, wann sie geladen oder freigegeben wird, dann geht das ungefähr so.

[DeddyH]

Das war die entscheidende Kleinigkeit, von der ich gesprochen hatte. Danke Dir herzlich

[Blup]

Für ein Plugin-DLL scheint es mir flexibel, wenn diese selbst die von ihr bereitgestellten Interfaces bei der Anwendung registriert.
Dazu wird dem Plugin ein Interface zum Anwendungskern übergeben, bei dem beliebige Interfaces registriert und abgefragt werden können.

Beispiel könnte ein Exportdateiformat sein. Davon kann es mehrere geben, für den Anwendungsfall ist es egal welche davon in der Anwendung oder in einem Plugin realisiert sind.
Der Dateiexport fragt alle registrierten Formate beim Anwendungskern ab, bietet diese dem Anwender an und erzeugt die Datei im gewählten Format.
Sollte dieses Dateiformat die Namen von Artikelgruppen benötigen, kann es dafür vom Anwendungskern ein Interface abfragen, das eine entsprechende Liste bereitstellt.
Das Dateiformat kann in der Plugin-Dll realisiert sein und die Schnittstelle mit den Artikelgruppen in der Anwendung.

[Sir Rufo]

Also in ungefähr so

Delphi-Quellcode:

IPlugin = interface
  ['{GUID}']
end;

IPluginHost = interface
  ['{GUID}']
  procedure RegisterPlugin( const Aplugin : IPlugin );
end;

Jede Plugin-DLL bietet eine Methode zum Abrufen an:

Delphi-Quellcode:

procedure QueryPlugin( const Host : IPluginHost ); stdcall;
begin
  Host.RegisterPlugin( TFooPlugin.Create );
  Host.RegisterPlugin( TBarPlugin.Create );
  ...
end;

[DeddyH]

Danke für die Denkarbeit, aber in diese Richtung geht es nicht (es gibt nur ein Interface, und jede DLL gibt exakt dieses zurück). Ich muss zugeben, dass der Begriff PlugIn in der Problemstellung etwas irreführend war.