DLLs in komplexen Programm

[hans ditter]

Also, erstmal danke für eure Antworten.
Ich hab mir die versch. Links mal angeschaut und durchgelesen, die beiden Foreneinträge sind mir noch zu speziell.
Das PDF-Dokument gefällt mir ganz gut. Ist halbwegs verständlich erklärt... aber eben nur halbwegs... (Die verwenden so komplizierte Namen und so...)

Also, es gibt eine DLL mit einer Klasse, die versch. Methoden implementiert (zur Verfügung stellt).
Dann gibt es noch ein Interface, welches (fast) alle Methoden dieser Klasse referenziert (also darauf zeigt).
Und schließlich gibt es wieder eine Klasse in der Hauptanwendung (HA), die eine Variable des Typs des Interface besitzt.
Korrigiert mich bitte, wenn was falsch ist!!

Alle drei genannten Sachen sollten in einer eigenen Datei liegen (DLL oder Unit).

In der Klasse der Hauptanwendung erzeuge ich eine Referenz auf das Interface. Falls dies gelingt, kann ich auf die Funktionen des Interface zugreifen.
Wenn ich also eine Prozedur P1 in dem Interface aufrufe, reicht das Interface diesen Aufruf an die Klasse in der DLL weiter, die dann ihre Aufgabe erledigt.
Ist das richtig?

Ich denke mal, meine Beschreibung ist jetzt noch seeeeehr grob...

Ich hab auch noch ein paar Fragen:

-> In dem Dokument ist immer wieder die Rede von "Basisklasse". Was sollte ich mir darunter vorstellen?

-> Auch erwähnt ist TInterfacedObject. Wozu braucht man das? Ich dachte, das übernimmt IUnknown...

-> Wie funktioniert das mit der Referenzverwaltung des Interface? Ich habe verstanden, dass, wenn eine neue Referenz erzeugt wird, der Referenzzähler von IUnknown um eins erhöht wird.
Aber wann wird der Referenzzähler wieder erniedrigt? Es hörte sich so an, als ob man sich darum überhaupt keinen Kopf machen muss...

-> Damit im Zusammenhang die letzte Frage. Der Referenzzähler zählt ja die Referenzen auf ein Objekt. Aber auf welches Objekt? Das Objekt das aus der Klasse in der DLL erzeugt werden kann? Oder die Referenzen auf das Interface?

Würde mich freuen, wenn ihr mir weiterhin so gut helfen würdet! Danke!

LG, hans ditter

[MGC]

Guten Morgen Hans Ditter,

ich sehe schon, es geht Dir ähnlich wie mir am Anfang. Delphi/Object Pascal und OOP (ObjektOrientierte Programmierung) sind auf den ersten Blick sehr verwirrend und umfangreich und viele Dinge (Klassen und deren Vererbung) erscheinen oftmals als schier unüberblickbare Konstrukte, deren Sinn sich einem einfach nicht erschließen möchte. Doch hat man erst einmal die Logik verstanden, ergeben sich plötzlich ungeahnte Möglichkeiten.

Für einen besseren Einstieg kann ich hier zwei Seiten empfehlen, die mich persönlich beim Einstieg bestens unterstützt haben:

Delphi-Lehrgang Einsteiger:
http://delphi.zsg-rottenburg.de/lektionen.html

Tutorials für Delphi:
http://www.michael-puff.de/Programmi...phi/Tutorials/

Bei den Tutorials zu Delphi von Michael Puff solltest Du Dir besonders die ersten drei Tutorials durchlesen (COM, Container-Klassen und Klassen), aber eins nach dem Anderen. Im Grundlehrgang findet sich eine sehr gute Erläuterung zur Klassendefinition (Ableiten von Basisklassen, Vererbung usw.).

Ich werde auch mal sehen, ob ich genügend Zeit aufbringen kann und mal ein kleines Beispiel zu Interfaces schreibe (Kann ich aber noch nicht versprechen).

Viele Grüße,
Marc

[Bummi]

@hans ditter

Wenn Du Dich mit Interfaces beschäftigen möchtest, würde ich Dir TInterFacedPersistent anstatt TInterfacedObject als Option ans Herz legen wollen.
Die IMHO intransparenete Speicherverwaltung von TInterfacedObject, bzw. darauf basiererend Komponenten fällt damit weg und alles verhält sich etwas mehr wie gewohnt.

[hans ditter]

@Bummi
Danke, werd ich mir merken.

@Marc
Danke für die Links, die les ich mir mal durch. Mal schauen, vielleicht ist mir dann ja schon einiges klarer.
Du hast allerdings Recht: Am Anfang ist das irgendwie alles seeehr unübersichtlich. Vor allem Vererbung ist manchmal sehr komisch...

LG, hans ditter

[hans ditter]

Oh mann... ich verstehs einfach nicht *heul*

Ich hab mir die ganzen Sachen durchgelesen. Dann hab ich versucht, dass ganze selbst mal umzusetzten. Ich hab das Ergebnis rangehängt. Aber es funktioniert überhaupt nicht. Schon beim Start sagt er mir, dass da ein Zugriffsfehler ist.
"...Exception der Klasse EReadError mit der Meldung 'Ungültiger Eigenschaftswert' aufgetreten."
Wenn ich dann auf Fortsetzen klicke:
"...Exception der Klasse EReadError mit der Meldung 'Fehler beim Lesen von Form1.OnCreate: Ungültiger Eigenschaftswert' aufgetreten."
Und dann stürzt das Programm ab...

Helft mir...bitte!

[MGC]

@Hans Ditter

Kann es sein das die angehängte ZIP-Datei nicht das fertige Projekt enthält?
Du hast nämlich noch keine Klasse in der DLL erstellt, die das Interface nutzt. Desweiteren hast DU keine globale Funktion über die Du Dir das Interface in Deine Anwenung meldest.
Nochdazu hast Du die DLL aus der Hauptanwendung heraus gar nicht in den Speicher geladen.
So funktioniert das nicht.

ich kann nur nochmal empfehlen:

1. Grundlehrgang für Delphi durcharbeiten
2. Tutorial von Olli (assarbad) zum Thema DLLs durcharbeit, dann wird auch Deine gesamte DLL plötzlich komplett anders aufgebaut sein.

Setze Dich dabei bitte auch explizit mit den Themen Klassen und Zeiger auseinander, damit der DLL-Aufruf und die Klassenimplementation auch funktioniert.

Grüsse,
Marc

[hans ditter]

hmm... da hab ich dann wohl grundlegend was falsch verstanden. Ich werd's mir nochmal anschauen und das ganze überarbeiten. Hast du nochmal einen Link für das DLL-Tutorial? Oder findet man das schnell über die Suche?

angenehme Nachtruhe,

hans ditter

[Bummi]

http://assarbad.net/en/stuff/tutorials/dll_tutorial/

[hans ditter]

Ich danke! Les es mir (wenn ich mal wieder Zeit hab ) durch.

[MGC]

@Hans Ditter

Ich habe noch einen kleinen Vorschlag, wie Dir die Realisierung Deines Projekts vielleicht besser gelingt und Du Dir Übersicht verschaffst.
Lege Dir doch ein Projekt als Prototyp an und erstelle alles in verschiedenen Forms udn Units, die Du bereits von anfang an logisch nach Deinem Schichten-Modell anlegst (Form für die GUI, Unit für die Logik der GUI; Datenmodul mit den Datensensitiven Komponenten, Unit für die Logik zum Datenmodul usw.).
Gehe die Anforderungen, die Du an das System stellst durch und plane sie in Klassen ein, die Du wiederum den verschiedenen Schichten zuordnest.
Wenn dieser Prototyp läuft, dann erst beginnst beginnst Du mit der Auslagerung in die DLLs und schreibst (je nach Realisierungs-Strategie) eine Konsolenanwendung (die eigentliche EXE-Datei), die schließlich die DLLs lädt...

Also, kurzgefasst würde ich folgendes Vorgehen vorschlagen:

1. Anforderungen an das zu erstellende System sammeln

2. Die Anforderungen analysieren und daraus zu erstelende Klassen, Objekte usw. ableiten
2.a. Die Realisierungsvorstellungen können dabei in kleinen Mini-Tests ausprobiert werden.
Auf diese Weise sieht man schon sehr schnell, ob und wie ein Grundgedanke sich umsetzen
läßt.

3. Das erstellte Modell in einem oder mehreren Prototypen programmatisch umsetzen
3.a. Hier können ggf. weitere Anforderungen erkennbar werden, die wiederum eingeplant um
umgesetzt werden müssen/können

ODER

3. Umsetzung des Gesamtprojekts in logischen und testbaren Teileinheiten, die später
zusammengefügt werden. (Kann/sollte dennoch mit Prototyping verbunden sein)

4. Fertigstellung des geplanten Systems

Besonders hilfreich wären hierbei auch die Unit-Tests mit DUnit. (Ein Gedankenansatz der später bei Dir mit Sicherheit ganz von allein hinzukommen wird...)

Viele Grüße,
Marc

P.S.: Häng Dich noch nicht zusehr an Dein geplantes Projekt, spiel doch mal ein wenig mit den Grundlagen herum. Schreib kleine Testprogramme, bis Dir die Strukturen für Dein Projekt klar werden.
(z.B.: einfach mal eine Klasse entwerfen; oder in Hinblick auf DLLs: schick doch einfach mal einen einfachen String in eine DLL, verändere ihn dort und sende ihn wieder zurück. Danach baust Du Dein Programm und auch Deine DLL ein wenig aus und wende Dich komplexeren Aufgaben zu.