Prozedurale Typen zur Laufzeit erstellen?

[BloodySmartie]

Hallo, liebe Community!

Ich frage mich gerade ob es möglich ist, Typendeklarationen wie die folgenden zur Laufzeit zu erstellen.

Delphi-Quellcode:

type foo=function:String;
type bar=function(s:string):integer;

Hat jemand ne Idee? Oder ist das generell nicht möglich?

Ich kann mir durchaus auch denken, dass die Frage sowieso unsinnig ist - aber das kam mir nunmal gerade in den Sinn und nun lass ich es an Euch aus 8)

[Tyrael Y.]

Verfolgst du ein bestimmtest Ziel?
Dann kann man deine Frage vielleicht besser beantworten.

[DeddyH]

Denk mal an dynamische Bindung von DLLs, dann sollte Dir die Antwort einfallen (Du kannst es natürlich auch einfach ausprobieren).

[edit] Moment: was meinst Du mit "zur Laufzeit erstellen"? [/edit]

[SirThornberry]

Das ist nicht möglich. Solche Typdefinitionen sind ja nur nötig damit der Compiler die Richtigkeit eines Aufrufes prüfen kann. Wenn du das ganze dynamisch zusammensetzt gibt es durch den Compiler keine Prüfung auf richtigkeit. Folglich gibt es das nicht und du musst den Aufruf von Grund auf selbst machen (Sachen auf Stack packen etc.)

Zitat:

Denk mal an dynamische Bindung von DLLs, dann sollte Dir die Antwort einfallen (Du kannst es natürlich auch einfach ausprobieren).

In wie fern sollte einem dann einfallen wie es geht zumal es ja meines erachtens nicht geht. Man kann zwar dynmaisch Funktionen aufrufen aber die Funktionstypen kann man da doch nicht dynmaisch zur Laufzeit erstellen.

[Sherlock]

Meinst Du sowas?

Delphi-Quellcode:

type
  TGetCallBack = procedure(CB: Pointer); stdcall;
.
.
.
procedure TForm1.Button1Click(Sender: TObject);
var
  GetCallBack: TGetCallBack;
.
.
.
    try
      @GetCallBack := GetProcAddress(MyDLLHandle, 'GetCallBack');
      if @GetCallBack <> nil then
        GetCallBack(@CallBack);

In diesem zerhackten Code wird sowas benutzt um eine Callback-Funktion zur Kommunikation zwischen einer DLL und dem aufrufenden Programm zu ermöglichen.

Sonst habe ich aber sowas noch nie gesehen.

Edit: Boah, bin ich langsam :stupid:
Edit2: Zur Laufzeit....öhm. Nö. :)

Sherlock

[DeddyH]

:lol: Jetzt haben wir gleichzeitig editiert.

[SirThornberry]

@Sherlock: Ich glaube nicht. Wie er einen solchen Typen definiert hat er ja oben gepostet.
Ich glaube er will so etwas wie RunDLL nachbauen.

Zitat:

:lol: Jetzt haben wir gleichzeitig editiert.

:lol:

[BloodySmartie]

Wow...so viele Antworten in so kurzer Zeit :)

Also ich arbeite gerade an einem Plugin-System, wobei ich für die Kommunikation zwischen Anwendung und Plugin halt auf fest definierte Funktionen setze, die die Anwendung in der Bibliothek aufrufen kann, sowie auf Callbacks, die die DLL selbst wiederum anspricht.

Nun muss man aber(nach meinem Wissensstand) bereits zur Entwurfszeit mindestens wissen, welche Parameter und Rückgabewerte Methoden aus der DLL besitzen. Damit meine ich, dass man das Programm für das Plugin anpassen muss. Deshalb habe ich mir die Frage gestellt, ob sich nicht gewissermaßen die Anwendung an das Plugin "anpassen" könnte. Vermutlich wäre das möglich, wenn ich Prozedurale Typen zur Laufzeit festlegen könnte.

Ich zeig Euch mal in Quelltextform, was ich meine:

DLL:

Delphi-Quellcode:

//Fehler? Nehmt es als Pseudocode ;)
...

Type TParameterType=(ptInt,ptSingle,ptString);

Type TUnknownProc=record
  procName:string;
  Parameters:array of TParameterType;
end;


function getInformationAboutAnUnknownProc:TParameterType;
begin
  result.procName:='doSomething';
  setlength(result.Parameters,1);
  result.Parameters[0]:=ptInt;
end;


procedure doSomething(a:integer);
begin
  showmessage(inttostr(a));
end;
...

exports 
        getInformationAboutAnUnknownProc name 'getInformationAboutAnUnkownProc',
        doSomething name 'doSomething';

Die mir bekannte Vorgehensweise in der Anwendung wäre nun:

Delphi-Quellcode:

//Fehler? Nehmt es als Pseudocode ;)
...
type TGetInfoFunc=function:TParameterType;
...
var GetInfos : TGetInfoFunc;
...
function Load_DLL (const dllfilename:string) :boolean;
begin
  dllhandle := LoadLibrary(pchar(dllfilename));
  if (dllhandle <> 0) then
    GetInfos := GetProcAdress(dllhandle,pchar('GetSomeInformationAboutAnUnkownProc'));
  end;
...

Wie Ihr seht, habe ich zunächst einen - zugegeben sehr einfachen - prozeduralen Typen "TGetInfoProc" deklariert, um dann eine entsprechende Funktion aus der DLL in mein Programm einzubinden. So weit, so gut.

Wie Ihr ebenfalls erkennen könnt, habe ich das für "doSomething" nicht getan - weil ich diese Funktion zur Entwurfszeit der Anwendung vielleicht noch nicht kannte. Nun habe ich mir gedacht, dass es doch cool wäre, wenn ich auch dafür einen solchen prozeduralen Typen basteln/erstellen/weiss-der-Fuchs-was könnte, um die noch unbekannte Funktion einzubinden. "GetSomeInformationAboutAnUnknownProc" liefert mir die Daten dafür. Jetzt würd' ich halt irgendwelche Delphi-Magie in Gang setzen wollen, um die Funktion ebenfalls nutzbar machen zu können.

Ich hoffe, das ich das jetzt einigermaßen verständlich schildern konnte.

[Sherlock]

Ich versuche mal zu verstehen:
Du willst ein Programm schreiben, daß eine Plugin-Schnittstelle anbietet. Diese Schnittstelle soll aber offen sein, insofern man beliebige weitere Methoden selber im Plugin einbauen kann, die das Hauptprogramm verstehen soll?

Das bietet IMHO kein anderes Plugin-System. Aus gutem Grund.

Sherlock

[BloodySmartie]

Ja, darum geht es in dem von mir erläuterten Beispiel.

Nein, ich will das nicht schreiben. Ich habe mich aber gefragt, ob und vor allem wie man das erreichen kann. Ich will mich nur fortbilden. Natürlich bin ich mir im Klaren darüber, dass man hier seine Tore öffnen würde. Allerdings gibts vielleicht noch andere Anwendungsgebiete, in denen zur Laufzeit erstellte Typen eher Sinn machen würden.