Klassen in DLL

[RWarnecke]

Hallo zusammen,

ich habe vor verschiedenste Klassen, die ich programmiert habe, in eine DLL zu packen. Ich habe schon ein bisschen im I-Net recherchiert. So einfach wie die Unit einbinden ist es ja nicht. Die Grundstruktur zum Einbinden habe ich hier schon im Entwicklerforum gefunden.

Dazu meine Frage, wenn ich jetzt mich an die Beschreibung halte, gibt es da irgendwelche größeren Stolpersteine ? Oder sollte ich besser Funktionen schreiben, die mir die einzelnen Werte von den Klassen zurückgeben ?

[sirius]

Und warum dann nicht gleich über Interfaces, wenn man schon über rein abstrakte Klassen nachdenkt?

[RWarnecke]

Zitat:

Zitat von sirius

Und warum dann nicht gleich über Interfaces, wenn man schon über rein abstrakte Klassen nachdenkt?

Was ist der Vorteil und Nachteil Interfaces vs. abstrakte Klassen ? Mit Interfaces habe ich noch nicht gearbeitet. Hast Du da zufällig Links mit Tutorials zur Hand, wo ich mich einlesen kann ?

[Assertor]

Guten Morgen Rolf,

ich bin zwar nicht Sirius, aber hier ist eine kleine Anfänger-Einführung in Interfaces zu finden:

http://mwcs.de/tutinterfaces.html

Gruß Assertor

[RWarnecke]

Zitat:

Zitat von Assertor

Guten Morgen Rolf,

ich bin zwar nicht Sirius, aber hier ist eine kleine Anfänger-Einführung in Interfaces zu finden:

http://mwcs.de/tutinterfaces.html

Gruß Assertor

Danke Assertor, werde das mal durcharbeiten. Wenn jemand noch weitere Tutorials kennt, bitte melden, damit ich so viel Info wie möglich bekomme.

[sirius]

Eine mögliche Vorgehensweise (noch ohne COM):

Delphi-Quellcode:

//Unit mit Interface-Deklaration für beide Programmteile:
type ImyInterface=interface
       ['{C55C5E2B-CC7D-4B8F-97BC-AB2A66EAAA33}'] //erstellen mittels [strg]+[shift]+[g]
       procedure doSomething;
       
       procedure setx(value:Integer);
       function getx:Integer;
       property x:Integer read getx write setx;
     end;

Delphi-Quellcode:

Nur in der DLL dann eine Klasse dazu implementieren:
type TmyInterfaceClass=class(TInterfacedObject,ImyInterface)
       //Hier jetzt die (3) Methoden von oben implementieren
       //zusätzlich können noch weitere Methoden und Felder in der Klasse sein,
     end;
     //du kannst jetzt auch weitere Klassen über dasselbe Interface implementieren

//und eine Funktion schreiben, welche das Interface liefert:
function getIntf:IUnknown;
begin
  result:=TmyInterfaceClass.create;
end;

Delphi-Quellcode:

//in der Exe bekommst du die Klasse dann mittels:
var intf:ImyInterface;
begin
  intf:=getIntf as ImyInterface;

[EWeiss]

Zitat:

Eine mögliche Vorgehensweise (noch ohne COM):

Frage mich warum das in Delphi so kompliziert ist ein Klasse für den zugriff von außen zu instanzieren.
In VB erstelle ich ein öffentliche Klasse ganz einfach.. ohne mich mit Interface-Deklaration rumzuschlagen.
Dll 'GenInterface' erstellen dort alle funktionen die ich in anderen Projekten verwenden will öffentlich machen.

Beispiel:

Delphi-Quellcode:

Public Property Get EQVisible() As Boolean
//
End Property

Public Property Let EQVisible(ByVal sEQVisible As Boolean)
//
End Property

Public Sub Execute(ByVal lngHwnd As Long)
//
End Sub

Public Function GetPlaylistBColor(ByVal mColor As OLE_COLOR) As OLE_COLOR
//
End Function

Public Function GetPlaylistFColor(ByVal mColor As OLE_COLOR) As OLE_COLOR
//
End Function

Das wars dann schon..
Nachher muss ich diese DLL als Interfacebrücke nur noch in meine Anwendung als Verweis einbinden.
Die Plugins welche dann mit meiner Anwendung kommunizieren sollen
müssen dann nur eine MasterClass besitzen bsp .. clsMain
Dort implementiere ich das Interface natürlich auch in der Anwendung.

Delphi-Quellcode:

Implements GenInterface.IPluginGen

Dort werden dann alle Funktionen (vererbungen des GenInterface) erneute deklariert.
Und dann kann man zwischen 'Anwendung <GenInterface > Plugin' kommunizieren

Delphi-Quellcode:

Private Property Get IPluginGen_EQVisible() As Boolean
    IPluginGen_EQVisible = EQVis
End Property

Private Property Let IPluginGen_EQVisible(ByVal sEQVisible As Boolean)
    EQVis = sEQVisible
End Property

Private Sub IPluginGen_Execute(ByVal lngHwnd As Long)
    Load frmBrowser
End Sub

Private Function IPluginGen_GetPlaylistBColor(ByVal mColor As stdole.OLE_COLOR) As stdole.OLE_COLOR
    mBackColor = mColor
    getColor = True    
End Function

Private Function IPluginGen_GetPlaylistFColor(ByVal mColor As stdole.OLE_COLOR) As stdole.OLE_COLOR
    mForeColor = mColor
End Function

Also warum ist das in Delphi so kompliziert?

EDIT:
Jede Anwendung die nun über die clsMain verfügt und das GenInterface als
Verweis einbindet kann nun mit meiner Anendung kommunizieren ohne
das sie die Interface-Bezeichnung (['{C55C5E2B-CC7D-4B8F-97BC-AB2A66EAAA33}']) kennen muss

gruss Emil

[SirThornberry]

Du kannst auch mit Packages arbeiten dann ist es ebenfalls so einfach. Wenn du allerdings DLLs verwendest und nicht das vorgefertigte musst du alles von Hand machen.
Warum ist das nicht so einfach: Weil die DLL und die Hauptanwendung im Normallfall ihre eigene Speicherverwaltung haben. Wenn du also mit Strings etc. hantierst muss man immer bedenken das reservierter Speicher dort frei gegeben wird wo er angefordert wurde etc.

[sirius]

(Add zu Sir)
Außerdem kann man in Delphi auch alles über COM machen. Da wird man von der IDE in allem unterstützt.

Abgesehen davon habe ich jetzt nicht verstanden, wo genau die Vereinfachung in VB liegt :gruebel:

[EWeiss]

Zitat:

Zitat von sirius

(Add zu Sir)
Außerdem kann man in Delphi auch alles über COM machen. Da wird man von der IDE in allem unterstützt.

Abgesehen davon habe ich jetzt nicht verstanden, wo genau die Vereinfachung in VB liegt :gruebel:

Ganz einfach das die GenInterface.dll als Brücke zwichen Anwenung .. und Plugin sprich anderer ExeAnwendung fungiert
Was versteht man da nicht :gruebel:

Brauche keine Com keine Interface Deklaration oder ähnliches.
Und muss auch nicht das Interface als solches kennen.

Zitat:

(['{C55C5E2B-CC7D-4B8F-97BC-AB2A66EAAA33}'])

Edit:
Sobald das Interface implementiert ist
kenne ich alle Funktionen Propertys proceduren ohne das ich mich weiter in die API
des Interface einarbeiten muss.
Und zwar in jeder Anwendung Dll oder Exe spielt dabei keine rolle.

gruss Emil