Funktion über ihren Namen als String aufrufen

[Der schöne Günther]

Puh, das wäre nicht mein Geschmack aber gut zu wissen :)

[Andreas L.]

Wie man eine Funktion über ihren Namen als String aufruft ist mir nicht bekannt. Klassen lassen sich aber über den Namen erzeugen. Du könntest also deine Funktionen als Klassen abbilden und den auszuführenden Code im Constructor unterbringen. Einen Rückgabewert kannst du ggf. als Property definiern. Für eine ggf. nötige Parameter-Übergabe muss man sich noch was einfallen lassen, aber das geht bestimmt. Die Lösung ist aber ziemlich umständlich, vielleicht kann man dein Vorhaben mit einer Scripting-Engine besser umsetzen (evtl. JvInterpreter aus der JVCL).

Delphi-Quellcode:

uses
  Classes;

...

  { -------------------------------------------------------------------------- }
  { TCsObjectCreator --------------------------------------------------------- }
  { -------------------------------------------------------------------------- }

  TCsObjectCreator = class(TObject)
  public
    class function CreateObjectByClassName(AClassName: String): TObject;
    class function CreateObjectByClassType(AClassType: TClass): TObject;
    class function FindClassByName(AClassName: String): TClass;
  end;

{ ---------------------------------------------------------------------------- }
{ TCsObjectCreator ----------------------------------------------------------- }
{ ---------------------------------------------------------------------------- }

class function TCsObjectCreator.CreateObjectByClassName(AClassName: string): TObject;
var
  MetaClass: TPersistentClass;
begin
  MetaClass := TPersistentClass(Self.FindClassByName(AClassName));

  Result := MetaClass.Create;
end;

class function TCsObjectCreator.CreateObjectByClassType(AClassType: TClass): TObject;
begin
  Result := AClassType.Create;
end;

class function TCsObjectCreator.FindClassByName(AClassName: string): TClass;
begin
  Result := FindClass(AClassName);
end;

Die Klassen müssen im initialization-Abschnitt mit RegisterClass(es) registriert werden:

Unit mit den "Funktionen":

Delphi-Quellcode:

  TBaseFunction = class;

  TTestFunction = class;

  TBaseFunctionClass = class of TBaseFunction;

  TBaseFunction = class(TPersistent)
  protected
    FResult: String;
  public
    class function GetClassName: String; virtual;
  published
    property Result: String read FResult;
  end;

  TTestFunction = class(TBaseFunction)
  public
    constructor Create; virtual;
    class function GetClassName: String; override;
  end;

...

class function TBaseFunction.GetClassName: String;
begin
  Result := 'TBaseFunction';
end;

constructor TTestFunction.Create;
begin
  FResult := 'Hallo Welt';
  // irgendwas machen
end;

class function TTestFunction.GetClassName: String;
begin
  Result := 'TTestFunction';
end;

...

initialization
  RegisterClass(TTestFunction);  // Edit: Evtl. muss der Parameter so aussehen: TPersistentClass(TTestFunction);

Aufruf aus dem Programm:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  Func: TObject;
begin
  // Objekt mittels String aus Edit1 erzeugen, constructor wird automatisch ausgeführt
  Func := TCsObjectCreator.CreateObjectByClassName(Edit1.text);  // in text steht z. B. TTestFunction
  
  // Objekt wurde erzeugt und ist abgeleitet von Basisklasse?
  if Assigned(Func) and (Func is TBaseFunction) then
  begin
    // Rückgabewert der "Funktion" anzeigen (oder in Var speichern)
    ShowMessage(TBaseFunction(Func).Result);
  
    // Erzeugtes Objekt freigeben
    FreeAndNil(Func);
  end;
end;

ungetestet

[DeddyH]

Zumindest parameterlose published-Proceduren kann man so aufrufen:

Delphi-Quellcode:

procedure Call(AObject: TObject; const Methodname: string);
type
  TProc = procedure of object;
var
  Method: TMethod;
  Proc: TProc;
begin
  Method.Data := AObject;
  Method.Code := AObject.MethodAddress(Methodname);
  if Assigned(Method.Code) then
    begin
      Proc := TProc(Method);
      Proc;
    end;
end;

Leider weiß ich nicht, seit welcher Delphi-Version es TMethod gibt, in Delphi 2007 ist sie jedenfalls bereits vorhanden.

[Andreas L.]

Zitat:

Zitat von DeddyH (Beitrag 1208239)

Zumindest parameterlose published-Proceduren kann man so aufrufen:

Delphi-Quellcode:

procedure Call(AObject: TObject; const Methodname: string);
type
  TProc = procedure of object;
var
  Method: TMethod;
  Proc: TProc;
begin
  Method.Data := AObject;
  Method.Code := AObject.MethodAddress(Methodname);
  if Assigned(Method.Code) then
    begin
      Proc := TProc(Method);
      Proc;
    end;
end;

Leider weiß ich nicht, seit welcher Delphi-Version es TMethod gibt, in Delphi 2007 ist sie jedenfalls bereits vorhanden.

Den Code (oder ähnlichen) habe ich mal in der Delphi-Hilfe gesehen. Auch nicht schlecht :) Rückgabewert und Parameter könnte man evtl. (unsauber) über globale Variablen über Felder bzw. Eigenschaften lösen. Der Vollständigkeit wegen:

Delphi-Quellcode:

  TForm1 = class(TForm)  
    ...
  private
    FProcResult: String;
    FProcParams: Array of String;
  ...
  end;

...

//var
//  ProcResult: String; // oder Variant, ...
//  ProcParams: Array of String;

...

procedure TForm1.TestProc;
begin
  if FProcParams[Low(FProcParams)] = 'Hallo' then
    FProcResult := 'Hallo'
  else
    FProcResult := 'Welt';
end;

...

ButtonClick:
begin
  // parameter festlegen
  SetLength(FProcParams, 1);
  FProcParams[1] := 'Hallo';

  // Proc aufrufen
  Call(Self, 'TestProc');

  // Rückgabewert anzeigen
  ShowMessage(FProcResult);
end;

[DeddyH]

Naja, wenn man aus Call eine (Klassen-)Methode macht, könnte man auf private (Klassen-)Felder zugreifen und somit auf globale Variablen verzichten.

[Furtbichler]

Wenn man die Routinen in einer DLL vorhält, kann man diese zur Laufzeit unter ihrem Namen aufrufen.

Delphi-Quellcode:

Procedure CallProcedure (aDLLHandle : THandle; aFunctionName : String; aInParam : Variant; Var aOutParam : Variant);
Var
  pProcPtr: TDLLProcedure;

Begin
  pProcPtr := GetProcAddress(aDLLHandle, PChar(aFunctionName));
  If Not Assigned(pProcPtr) Then
    Raise Exception.CreateFmt('Function "%s" Not Found (%d)', [aFunctionName, GetLastError]);
  aOutParam := Null;
  pProcPtr(aInParam, aOutParam);
End;

Der Schnippsel ist aus einem Uralt-Projekt wo mit Plugins gearbeitet wurde.

[Andreas L.]

Zitat:

Zitat von DeddyH (Beitrag 1208244)

Naja, wenn man aus Call eine (Klassen-)Methode macht, könnte man auf private (Klassen-)Felder zugreifen und somit auf globale Variablen verzichten.

Ist mir nach dem posten auch eingefallen. Hab' den Beitrag daher editiert.