| Autor |
Beitrag |
MrSaint
      
Beiträge: 1033
Erhaltene Danke: 1
WinXP Pro SP2
Delphi 6 Prof.
|
Verfasst: Mo 15.11.04 22:39
Hi!
Ich entwickle gerade an einer DLL, welche einen DLL-Client (KEIN Server) darstellen soll. Soweit alles okay, ich habe eine Methode, welche ein Instanz eines Interfaces erzeugt und auch mit ihm erfolgreich kommuniziert. Funzt also gut. Wenn ich jetzt aber diese Methode zwischen den begin..end-Block der DLL schriebe (also so, dass die Methode ausgeführt wird, wenn die DLL geladen wird), gibts ne AV, wenn ich die DLL in ein Projekt statisch einbinde, lade ich die DLL dynamisch, hängt sie sich einfach auf bei dem Befehl
Delphi-Quelltext
(DLL ist vom Typ IDLL, mein Interface und CoDLL is die dazugehörige CoClass).. So, das is natürlich super unschön  *g* also ich sollte das auf jeden fall so laufen haben, dass ich auch schon zur "Einbindzeit" der DLL diese Verbindung zum Interface aufbauen kann (die DLL muss sich praktisch bei meinem COM-Server anmelden).. Weiß jemand wie ich dass bewerkstellugen könnte? Also sieht ja ganz danach aus, dass irgendwas noch nicht richtig initialisiert ist und deswegen das COM rumspinnt (-> wie genau is die initialisierungsreihenfolge? steckt der fehler da drin?)... Wie gesagt, rufe ich die Methode NICHT zu Einbindzeit auf sondern später z.B. per Mausklick in meinem Programm, geht alles!
MrSaint
_________________ "people knew how to write small, efficient programs [...], a skill that has subsequently been lost"
Andrew S. Tanenbaum - Modern Operating Systems
|
|
Udontknow
      
Beiträge: 2596
Win7
D2006 WIN32, .NET (C#)
|
Verfasst: Di 16.11.04 11:46
Hallo!
| Zitat: | | Ich entwickle gerade an einer DLL, welche einen DLL-Client (KEIN Server) darstellen soll. |
Wie? Eine DLL kapselt ein oder mehrere COM-Objekt-Factories, und andere Programme erzeugen beizeiten ein COM-Objekt mithilfe dieser Factories. Was meinst du mit obigem Statement?
| Zitat: | | Soweit alles okay, ich habe eine Methode, welche ein Instanz eines Interfaces erzeugt und auch mit ihm erfolgreich kommuniziert. Funzt also gut. |
Ein Interface kann nicht instanziiert werden. Ein Interface ist einfach nur eine Schnittstelle zu einem von der in der DLL liegenden Factory erstellten Com-Objekt.
| Zitat: | | Wenn ich jetzt aber diese Methode zwischen den begin..end-Block der DLL schriebe (also so, dass die Methode ausgeführt wird, wenn die DLL geladen wird), gibts ne AV, wenn ich die DLL in ein Projekt statisch einbinde, lade ich die DLL dynamisch, hängt sie sich einfach auf bei dem Befehl |
Was für Code ist das denn? Aber du solltest diesen auch eher im entsprechenden COM-Objekt implementieren, z.b. die Methode Initialize übersteuern, die DLL selber ist nicht der richtige Ort.
Cu,
Udontknow
|
|
MrSaint 
      
Beiträge: 1033
Erhaltene Danke: 1
WinXP Pro SP2
Delphi 6 Prof.
|
Verfasst: Di 16.11.04 12:40
Mmmm.... du hast da was flash verstanden. Die DLL ist bei mir NICHT der Server (also KEIN InProc-Server!!), sondern der Client, der sich zu einem LocalServer connecten soll.. Alo brauch ich auch kein eClassFactories oder sonst was in der DLL, es reicht einfach
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9:
| var DLL: IDLL; wID: integer begin DLL := CoDLL.Create; wID := DLL.Login(Parameter1, Parameter2); DLL.Log(wID, irgendwas); DLL.Logout(wID); DLL := nil; |
Also der Server steckt in ner EXE, der Client soll in die DLL... Die Facotries sind in der EXE... also in der EXE steckt ne Klasse á la
Delphi-Quelltext 1: 2: 3: 4:
| type DLL = class(TAutoObject, IDLL) [...] end; |
| Zitat: | | Ein Interface kann nicht instanziiert werden. Ein Interface ist einfach nur eine Schnittstelle zu einem von der in der DLL liegenden Factory erstellten Com-Objekt. |
Okay, so fit bin ich mit den Ausdrücken noch net
| Zitat: | | Was für Code ist das denn? Aber du solltest diesen auch eher im entsprechenden COM-Objekt implementieren, z.b. die Methode Initialize übersteuern, die DLL selber ist nicht der richtige Ort. |
Also ich will z.B. grad obigen Code einfach nur ausführen, wenn die DLL geladen wird.. (und der Code muss in die DLL rein, weil die DLL beliebig oft von irgendwlechen Anwendungen geladen wird)..
Ich hoff das wurde nu klar, was ich will  (net bös gemeint!)
MrSaint
_________________ "people knew how to write small, efficient programs [...], a skill that has subsequently been lost"
Andrew S. Tanenbaum - Modern Operating Systems
|
|
Udontknow
      
Beiträge: 2596
Win7
D2006 WIN32, .NET (C#)
|
Verfasst: Di 16.11.04 14:14
Dir sind da anscheinend ein paar grundlegende Sachen bei COM noch nicht bekannt.
Delphi-Quelltext 1: 2: 3: 4:
| class function CoTest.Create: ITest; begin Result := CreateComObject(CLASS_Test) as ITest; end; |
Schau dir mal Coclass.Create an. Deine CoClass mach nichts anderes, als über die WinAPI CreateComObject aufzurufen. Das Betriebssystem schaut nun anhand der übergebenen Class-ID in der Registry nach, in welcher DLL das geforderte Com-Objekt seine Fabrik (ein Objekt vom Typ TComObjectFactory) hat. Die DLL wird vom Betriebssystem geöffnet und mit ihr wird durch den Initialization-Abschnitt der Com-Objekt-Unit folgender Code aufgerufen:
Delphi-Quelltext 1: 2: 3: 4:
| initialization TTypedComObjectFactory.Create(ComServer, TTest, Class_Test, ciMultiInstance, tmApartment); end. |
Sobald also eine ActiveX-DLL geöffnet wird, werden die Factories sämtlicher implementierter Com-Objekte erzeugt.
Diese Factory wird dann vom Betriebssystem angesprochen und erstellt das Objekt, zu dem du dann ein Interface als Result erhäst. Ohne Factory läuft das nicht.
BTW: Der Name DLL ist für ein Com-Objekt äusserst unglücklich gewählt, da, wie bereits erwähnt, mehrere COM-Objekte in einer DLL sich befinden können.
Was ist also das Problem? Der "Server" ist eine Exe. Gut. Wenn der "Server" nun diese COM-Objekte benutzen soll, dann tut er das , aber eben als Client. Oder wer soll sonst die in der DLL befindlichen COM-Objekte instanziieren?
Cu,
Udontknow
|
|
MrSaint 
      
Beiträge: 1033
Erhaltene Danke: 1
WinXP Pro SP2
Delphi 6 Prof.
|
Verfasst: Di 16.11.04 15:18
| Zitat: | | Das Betriebssystem schaut nun anhand der übergebenen Class-ID in der Registry nach, in welcher DLL das geforderte Com-Objekt seine Fabrik (ein Objekt vom Typ TComObjectFactory) hat. Die DLL wird vom Betriebssystem geöffnet und mit ihr wird durch den Initialization-Abschnitt der Com-Objekt-Unit folgender Code aufgerufen: |
Stimmt soweit, so will ich das aber gar nicht! Eine Class Factory kann nicht nur in einer DLL sein, sondern auch in einer ganz normlen EXE! und bei mir is die komplette Deklaration in der EXE! Also ich beschreibs glaub nochmal
Ich habe eine EXE, welche als (COM)Server fungiert. Diese wird aufgerufen, wenn irgendwo irgendetwas (in meinem Fall: meine DLL) die Class-ID von IDLL an CreateComObject übergibt. Also COM is ja praktisch ausgedrückt eine Möglichkeit eine Funktion seines eigenen Programmes allen anderen Programmen zugänglich zu machen. Bei mir tut das die EXE, nennen wir sie mal "Server.exe". Also die Server.exe implementiert die Klasse TDLL = class (TAutoObject, IDLL), welche die Implementation von IDLL ist. DDas macht die Server.exe!!! Ich kann da auch perfekt drauf zugreifen und so weiter, funzt soweit.
Jetzt komme ich aber daher und will, dass eine DLL diese exportieren Funktionen der Server.exe benutzen kann. Bei deisen exportierten Funktionen handelt es sich momentan gerade mal um eine Methode zum Einloggen, aine zum Ausloggen und eine, mit der man eine Log-message an den Server schicken kann. Gut? Also ich poste mal den kompletten Quelltext der DLL hier hinein:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27:
| library SaintSecureTestDLL;
uses SysUtils, Classes, SaintSecureServer_TLB in '..\SaintSecureServer_TLB.pas'; {$R *.res}
function StartTest: Word; stdcall; var DLL : IDLL; wLogLevel, wID : Word; bDecryptOnCopy : byte; begin DLL := CoDLL.Create; wID := DLL.Login('TESTDLL', wLogLevel, bDecryptOnCopy); DLL.Log(wID, $FFFF, 'HELP!'); DLL.Logout(wID); DLL := nil; end;
exports StartTest;
begin end. |
So, das is alles, was in der DLL is. die SaintSecureServer_TLB is eben die Deklaration des Interfaces, welches in der Server.exe implementiert wird. Also in der Server.exe findet man sowas:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12:
| uses ComObj, ActiveX, SaintSecureServer_TLB, StdVcl, Classes;
type TDLL = class(TAutoObject, IDLL) protected function Login(FileName: PChar; out LogLevel: Word; out DecryptOnCopy: Byte): Word; safecall; procedure Log(ID, LogLevel: Word; Text: PChar); safecall; procedure Logout(ID: Word); safecall; end; |
und diese Klasse is auch "mit Leben gefüllt"... So, ich hoffe nu endlich isses klar, was ich will  Die Server.exe ist der COM-Server, NICHT die DLL!!!
ich produzier hier keinen InProcess-Server (das wäre mit DLL: Wenn ein Programm die Klasse mit der CLSID anfordert, wird die DLL in den peicherbereich des rufenden Prozesses geladen), sondern einen "Local Server" (der COM-Server ist in einer EXE: Wenn ein Programm (in meinem Fall ne DLL) die Klasse mit der CLSID anfordert, startet COM die Server-EXE und managt dann den Zugriff auf die "exportierten" Funktionen des Servers per Marshaler).. Ich meine, nen InProcess-Server könnt ich auch mit ner normalen DLL realisieren, das mit dem Marshaler is (so finde ich) der eigentlich riesige Vorteil von COM. Es mappt praktisch fremde funktionen in den Adressraum des gerade ausführenden Prozesses ohne die Funktionen an sich zu kopieren, sondern per Marshaller...
Sodala. Und nu nommal mein problem: Ich erstelle jetzt eine weitere Anwendung (nicht die Server.exe, nicht die DLL), eine normale EXE. Diese lädt diese DLL. Ist die DLL jetzt so, wie der Code oben (also das "StartTest" zw. begin und end. auskommentiert) und ich rufe STartTest von der Anwendung aus auf, dann funktioniert alles wunderbar! die DLL kommuniziert mit dem Server und alles toll. Kommentiere ich diese Zeile nun aber wieder ein, so bekomm ich eine Access-Violation, wenn ich die DLL statisch in die neue Anwendung einbinde und wenn ich sie dynamisch einbinde (also über LoadLibrary), dann bleibt er einfach in der Zeile "DLL := CoDLL.Create;" hängen und macht nicht weiter. Das ist mein Dilemma
MrSaint
P.S.: *hoff* dass ichs nu endlich richtig rübergebracht hab! 
_________________ "people knew how to write small, efficient programs [...], a skill that has subsequently been lost"
Andrew S. Tanenbaum - Modern Operating Systems
|
|
Udontknow
      
Beiträge: 2596
Win7
D2006 WIN32, .NET (C#)
|
Verfasst: Di 16.11.04 15:31
Pfff... OK, so langsam rattert es.
Aber das CoDLL.Create klappte direkt in einer Anwendung? Wie sieht das denn mit "CoInitialize " aus, muss man das evtl. für die DLL separat aufrufen?
Cu,
Udontknow
|
|
MrSaint 
      
Beiträge: 1033
Erhaltene Danke: 1
WinXP Pro SP2
Delphi 6 Prof.
|
Verfasst: Di 16.11.04 15:47
| Zitat: | | Aber das CoDLL.Create klappte direkt in einer Anwendung? |
Also wie gesagt, das CoDLL.Create funzt perfekt, wenn ich die Zeile 26 der DLL auskommentiert lass und StartTest nacher aus einem programm per Hand aufruf, also z.B.:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8: 9:
| procedure TForm1.Button1Click(Sender: TObject); var StartTest : Pointer; hDLL : integer; begin hDLL := LoadLibrary('SaintSecureTestDLL.dll'); StartTest := GetProcAddress(hDLL, 'StartTest'); TProcedure(StartTest); end; |
bzw. bei statischem Einbinden:
Delphi-Quelltext 1: 2: 3: 4: 5: 6: 7: 8:
| procedure StartTest; external 'SaintSecureTestDLL.dll';
...
procedure TForm1.Button1Click(Sender: TObject); begin StartTest; end; | (Code aus einer normalen anwendung).
Kommentier ich diese 26. Zeile aber ein, gehts nemme. Dann bekomm ich bei statischer Einbindung eine Zugriffsverletzung und bei dynmaischer bleibt er bei "CoDLL.Create" hängen... Ich bräuchte das aber halt so, dass ich das auch ausführen kann, wenn die DLL geladen wird.
CoInitialize brauch ich doch für einen COM-Client (was meine DLL ja is) doch nicht, oder? Sonst würde das ja auch nich "per Buttonklick" funzen... Das brauchen doch nur die COM-Server...
MrSaint
_________________ "people knew how to write small, efficient programs [...], a skill that has subsequently been lost"
Andrew S. Tanenbaum - Modern Operating Systems
|
|
venzip
Hält's aus hier
Beiträge: 3
|
Verfasst: Di 16.11.04 17:14
Titel: Ausserhalb der DLL initialisieren
Hi,
was passiert wenn du eine zweite DLL schreibst, welche beim Laden die erste aufruft?
|
|
Udontknow
      
Beiträge: 2596
Win7
D2006 WIN32, .NET (C#)
|
Verfasst: Di 16.11.04 17:15
| Zitat: | CoInitialize brauch ich doch für einen COM-Client (was meine DLL ja is) doch nicht, oder? Sonst würde das ja auch nich "per Buttonklick" funzen... Das brauchen doch nur die COM-Server...
|
Also da bin ich anders informiert. Probiers mal aus.
Cu,
Udontknow
|
|
MrSaint 
      
Beiträge: 1033
Erhaltene Danke: 1
WinXP Pro SP2
Delphi 6 Prof.
|
Verfasst: Di 16.11.04 20:00
Titel: Re: Ausserhalb der DLL initialisieren
| venzip hat folgendes geschrieben: | Hi,
was passiert wenn du eine zweite DLL schreibst, welche beim Laden die erste aufruft? |
komsich, das funzt auch nich... Stimmt aber, klingt eigentich logisch dass das hätte funktionieren müssen...
| Zitat: | | Also da bin ich anders informiert. Probiers mal aus. |
Ausprobiert --> kein unterschied. Aber bräuchte ich das CoInitialize, dann dürfte die Version mit Zeile 26 auskommentiert ja auch nicht funktionieren, weil ja da kein CoInitialize drin steht... Aber das geht ja!
MrSaint
_________________ "people knew how to write small, efficient programs [...], a skill that has subsequently been lost"
Andrew S. Tanenbaum - Modern Operating Systems
|
|
Udontknow
      
Beiträge: 2596
Win7
D2006 WIN32, .NET (C#)
|
Verfasst: Mi 17.11.04 09:13
Na, welche Ursache das auch immer hat, dann musst du eben vorher noch eine Routine Initialize aufrufen, das macht den Braten ja nun auch nicht fett, oder?
Ich habe mir das noch einmal durch den Kopf gehen lassen. Ist das Ziel nun, alle Clients mit EINEM Com-Objekt zu verbinden?
Dann ist da aber noch mehr nötig, ein Out-Of-Process-Server ist schön und gut, aber die Factory erstellt trotzdem für jeden Aufruf ein neues COM-Objekt, du müßtest also die Funktion CreateComObject der Factory des Servers übersteuern, um nach der Erstellung des ersten Objekts nur noch dieses zurück zu geben, anstelle immer wieder neue Instanzen zu erzeugen.
Cu,
Udontknow
|
|
MrSaint 
      
Beiträge: 1033
Erhaltene Danke: 1
WinXP Pro SP2
Delphi 6 Prof.
|
Verfasst: Mi 17.11.04 11:01
| Zitat: | | Na, welche Ursache das auch immer hat, dann musst du eben vorher noch eine Routine Initialize aufrufen, das macht den Braten ja nun auch nicht fett, oder? |
Also ich hab nu gestern abend nochmal im Entwickler-Forum nachgefragt, weil da praktisch "die Quelle" (wenn ich das mal so nennen darf) Andreas Kosch sitzt... mit nem Buch von dem hab ich mich nämlich in COM eingeführt, der sollte also 100% ahnung haben  So, also du hattest natürlich recht, das CoInitialize brauch ich, auch wenn ich dann nich ganz versteh, warum es auch ohne klappt (wenn ich die Prozedur per "Buttonklick aufrufe)... Naja, wird scho passen
Außerdem hat er noch gesagt, dass ich das über eine DLLProc machen soll (also praktisch einfach den Pointer DLLProc neu belegen mit ner Adresse iener Prozedur). Die Prozedur wird dann immer angesprungen, wenn das System die DLL lädt oder entlädt oder neue Threads anhängt/abhängt... Und dann muss ich da anscheinend nochmal genau im Windows SDK nachlesen, was ich da nun ausführen darf und was nicht. Aber ich befürhcte, dass ich keine COM initialisierung ausführen darf, sonst würds ja gehn :/
Hab aber im moment grad net genug Ruhe, das auszutesten, werd das heut abend irgendwann machen... Ihr bekommt dann die Infos, wenn ich weiß wie's geht
MrSaint
_________________ "people knew how to write small, efficient programs [...], a skill that has subsequently been lost"
Andrew S. Tanenbaum - Modern Operating Systems
|
|
MrSaint 
      
Beiträge: 1033
Erhaltene Danke: 1
WinXP Pro SP2
Delphi 6 Prof.
|
Verfasst: Mi 17.11.04 16:36
| MSDN hat folgendes geschrieben: | | Calling imported functions other than those located in Kernel32.dll may result in problems that are difficult to diagnose. For example, calling User, Shell, and COM functions can cause access violation errors, because some functions in their DLLs call LoadLibrary to load other system components. Conversely, calling those functions during termination can cause access violation errors because the corresponding component may already have been unloaded or uninitialized. |
Na toll.. weiß jemand wie ich überprüfen kann, ob der komplette Initialisierungsvorgang einer DLL schon abgeschlossen is? dann könnt ich vllt nen Thread generieren, der solang wartet, bis die Initialisierung fertig is und dann meine COM sache erledigt... Einen Thread sollt ich ja erzeugen können mit CreateThread und CreateThread is in der Kernle32.dll und die Funktionen sollen ja funktionieren:
| MSDN hat folgendes geschrieben: | | It is safe to call other functions in Kernel32.dll, because this DLL is guaranteed to be loaded in the process address space when the entry-point function is called. |
MrSaint
_________________ "people knew how to write small, efficient programs [...], a skill that has subsequently been lost"
Andrew S. Tanenbaum - Modern Operating Systems
|
|
MrSaint 
      
Beiträge: 1033
Erhaltene Danke: 1
WinXP Pro SP2
Delphi 6 Prof.
|
Verfasst: Do 18.11.04 20:43
So, möcht euch natürlcih nun meine Lösung nicht vorenthalten! Hier ist sie (DLL):
1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: 49: 50: 51: 52: 53: 54: 55: 56:
| library SaintSecureTestDLL;
uses SysUtils, Classes, ActiveX, Windows, SaintSecureServer_TLB in '..\SaintSecureServer_TLB.pas';
{$R *.res}
var cThreadID : Cardinal; booDone : boolean;
const THREAD_TERMINATE = 1;
function StartTest: Word; stdcall; var DLL : IDLL; wLogLevel, wID : Word; bDecryptOnCopy : byte; begin CoInitialize(nil); DLL := CoDLL.Create; wID := DLL.Login('TESTDLL', wLogLevel, bDecryptOnCopy); DLL.Log(wID, $FFFF, 'TestMessage'); DLL.Logout(wID); DLL := nil; CoUninitialize; booDone := true; end;
procedure CheckThread; stdcall; var cThreadSTartTestID, cThreadHandle : Cardinal; begin booDone := false; repeat cThreadHandle := CreateThread(nil, 0, @StartTest, nil, THREAD_TERMINATE, cThreadStarttestID); WaitForSingleObjectEx(cThreadHandle, 3000, false); TerminateThread(cThreadHandle, 1); until booDone; end;
exports StartTest;
begin DisableThreadLibraryCalls(GetModuleHandle('SaintSecureTestDLL.dll')); CreateThread(nil, 0, @CheckThread, nil, 0, cThreadID); end. |
So, wie ihr seht erzeug ich beim Initialisieren nu erst mal nen Thread (Prozedur CheckThread). Dieser Thread erzeugt nun einen weiteren Thread, der versucht die Verbindung aufzubauen. Hat der das nach 3 Sekunden noch nicht geschafft, wird er knallhart abgebrochen  (die 3 sekunden werden bei einer Veröffentlichung des Tools natürlich mehr sein, dass die langsamen PCs auch mitkommen  ). Das war auch schon der ganze Trick dabei  Anzumerken is, dass die Instanz der CoClass, welche ich nu in dem "2. Thread" bekommen hab (also in der Prozedur Starttest), auch erstmal nur da gültig is. Will man dieses Interface in einem anderen Thread (z.B. dem Mainthread) benutzen, muss man ein bisschen Marshalling per Hand durchführen. Siehe dazu z.B. Buch: COM/DCOM/COM+ von Andreas Kosch Kapitel 4.7. Für die die das Buch nicht haben, die sollten sich vllt. mal die API-Funktionen COMARSHALINTERTHREADINTERFACEINSTREAM, COGETINTERFACEANDRELEASESTREAM, evtl. COUNMARSHALINTERFACE und COMARSHALINTERFACE anschauen.
MrSaint
_________________ "people knew how to write small, efficient programs [...], a skill that has subsequently been lost"
Andrew S. Tanenbaum - Modern Operating Systems
|
|
|