Funktion über ihren Namen als String aufrufen

[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

[Sir Rufo]

Zitat von Der schöne Günther:

Ich habe zwar das Delphi Language Coding Standards Document oder den Object Pascal Style Guide zwar noch nicht durchgeackert. Aber darf man trotzdem fragen, warum eigentlich das A als Prefix?

Weil es dadurch klarer wird

Delphi-Quellcode:

type
  TMyClass = class
  strict private
    _Value : string; 
  private
    FValue : string;
    function GetValue : string;
  public
    function GetSomething( const AValue : string ) : string;
    property Value : string read GetValue;
  end;

function TMyClass.GetValue : string;
begin
  Result := '_' + FValue + '_';
end;

function TMyClass.GetSomething( const AValue : string ) : string;
var
  LValue : string;
begin
  LValue := 'Something';
  
  Result := 
    LValue + // local variable
    AValue + // attribute
    _Value + // strict private class field
    FValue + // private class field
    Value;   // property
end;