DLLs dynamisch zur Laufzeit einbindet
-
Ich habe folgendes Problem:
Ich habe eine Hauptanwendung, die mehrere DLLs dynamisch zur Laufzeit einbindet
und deren Funktionen aufruft. Aus den Funktionen der DLLs soll es aber auch möglich sein, Funktionen des Hauptprogrammes aufzurufen.Noch eine Anmerkung: Das Hauptprogramm kennt die DLLs und die aufgerufenen Funktionen erst zur Laufzeit.
Diese werden aus einer XML-Datei ausgelesen.Wie stelle ich es am geschicktesten an? Vielen Dank für eure Antworten.
-
Callbackfunktionen des Hauptprogrammes in die DLL rein geben. Elegant könntest Du das z.B. mit einer Factory erledigen, die ein Objekt liefert das die interne Funktion des Hauptprogrammes aufruft.
-
Kannst Du mir bitte etwas mehr Info geben, bin nämlich ziemlich neu in C++/CLI.
-
Es geht mehr um Entwurfsmuster als um die Umsetzung in der Sprache selbst.
Der Gedanke war folgender.Sind das antive DLLs oder .Net Dlls ?
Grundlegend muss die DLL einen Delegaten (Callback) aus dem Hauptprogramm erhalten. (Es sein denn, es gibt bereits ein anderes Protokoll zur Kommunikation).
Ich stelle mir das bei Dir so vor, das alles irgendwie unbekannt ist. Das Hauptprogramm stellt aus Sicht der DLL eine unbekannte Anzahl von Funktionen zur Verfügung, die sich auch stehts ändern kann ohne das man alle DLLs neu Übersetzen will.
Auf der anderen Seite weiß das Hauptprogramm nicht so recht, was ihm da mit den DLLs angetan wird.
Der Gedanke ging in die Richtung, eine Fabrik eine Befehlsklasse erzeugen zu lassen. Hierfür würde diese einfach einen Namen entgegen nehmen und daran das passende Befehlsobjekt erzeugen. (Du kannst hier auch auf unbekannte Funktion sehr elegant reagieren).
Das Befehlsobjekt könnte wiederum ein Array von Objekten entgegen nehmen.
(In C# wäre das params http://msdn2.microsoft.com/en-us/library/w5zay9db(vs.71).aspx , im klassischen C die "...". Ich hab sowas in C++/CLI nicht implementiert, ka wie man das da am besten machen würde).Die DLL ruft die Funktion auf, also wird sie diese kennen und kann in diesem Array die Notwendigen Parameter entegegen nehmen. Das Befehlsobjekt weiß das ebenso und kann sich aus dem Array bedienen.
Der Vorteil der Methode: Man bekommt um das Problem der Signaturen der Funktionen herum weil man die Parameter beliebig angeben kann.
Der Nachteil ist erst einmal der Verlust der Typinformation des Parameters. (Das kann durchaus ein k.O. Kriterium sein, das Prüfen etc. kostet schliesslich Zeit).
Alternativ zu der Typinformation könnte man sich ein wenig an das Hauptprogramm binden. In diesem Falle würde ich die Fabrik keine Befehlsobjekte mehr liefern lassen sondern Delegaten bzw. Funktionszeiger. Hierfür muss der DLL dann aber Details des Hauptprogrammes bekannt sein und muss immer auf das Hauptprogramm angepasst werden wenn sich da etwas ändert. (Mit dem Befehlsobjekt könntest Du interne Änderungen besser vor der DLL verstecken).
Die einfachste Variante wäre (vorallem wenn es nur 2 oder 3 Aufrufe sind), diese der DLL beim Laden zu übergeben. Hierfür muss jede DLL halt eine Initialisierungsroutine bereit stellen, die entsprechende Funktionszeiger des Hauptprogrammes entgegen nimmt. (Einfach zu Programmieren, jedoch große Bindung an das Hauptprogramm).
Ich denke aber sicherlich wieder zu Komplex, vllt. hat noch jemand ne Idee.
Weitere Details schaden auf jedenfall nicht, nur dann kann man eigentlich einen guten Weg vorschlagen.
(Zur Implementierung kommen wir, wenn der Weg bekannt ist)