Delphi: Chiamare una funzione il cui nome è memorizzato in una stringa

Question

E 'possibile chiamare una funzione il cui nome è memorizzato in una stringa in Delphi?

Answer 1

Si prega di fornire maggiori dettagli su che cosa stai cercando di ottenere.

Per quanto ne so:

• Non è possibile chiamare una funzione random del genere.
• Per le funzioni classe e oggetto (MyObject.Function) questo può essere fatto con RTTI, ma è molto lavoro.
• Se hai solo bisogno di chiamare un particolare tipo di funzioni (ad esempio, funzione (numero intero, intero): stringa), è molto più semplice.

Per l'ultimo, dichiarare un tipo di funzione, quindi ottenere un puntatore a funzione e gettato in questo modo:

type 
    TMyFuncType = function(a: integer; b: integer): string of object; 

    TMyClass = class 
    published 
    function Func1(a: integer; b: integer): string; 
    function Func2(a: integer; b: integer): string; 
    function Func3(a: integer; b: integer): string; 
    public 
    function Call(MethodName: string; a, b: integer): string; 
    end; 

function TMyClass.Call(MethodName: string; a, b: integer): string; 
var m: TMethod; 
begin 
    m.Code := Self.MethodAddress(MethodName); //find method code 
    m.Data := pointer(Self); //store pointer to object instance 
    Result := TMyFuncType(m)(a, b); 
end; 

{...} 

//use it like this 
var MyClass: TMyClass; 
begin 
    MyClass := TMyClass.Create; 
    MyClass.Call('Func1', 3, 5); 
    MyClass.Call('Func2', 6, 4); 
    MyClass.Destroy; 
end. 

Answer 2

Se stai chiedendo se c'è qualcosa come il eval() JavaScript è possibile in Delphi, no questo non è (facilmente) realizzabile poiché Delphi compila il codice nativo.

Se è necessario solo per supportare alcune stringhe si può sempre fare molte if o un case ... Qualcosa di simile:

if myString = 'myFunction' then 
    myFunction(); 

Answer 3

Si può fare qualcosa di simile per la lavorazione di una o più classi con proprietà pubblicati che utilizzare le funzioni per implementare le funzionalità di lettura e scrittura. Le proprietà possono quindi essere scoperte utilizzando la riflessione RTTI e referenziate, causando il richiamo delle funzioni sottostanti.

In alternativa, è possibile memorizzare i puntatori alle funzioni in una tabella, o anche la proprietà oggetto di TStringList ed efficace li indice nome di stringa.

Diritto chiamata di una funzione per nome non è possibile in Delphi.

Answer 4

Mi sorprende che nessuno ha suggerito un dispatch table. Questo è esattamente ciò che è per.

program RPS; 

uses 
    SysUtils, 
    Generics.Collections; 

type 
    TDispatchTable = class(TDictionary<string, TProc>); 

procedure Rock; 
begin 
end; 

procedure Paper; 
begin 
end; 

procedure Scissors; 
begin 
end; 

var 
    DispatchTable: TDispatchTable; 

begin 
    DispatchTable := TDispatchTable.Create; 
    try 
    DispatchTable.Add('Rock', Rock); 
    DispatchTable.Add('Paper', Paper); 
    DispatchTable.Add('Scissors', Scissors); 

    DispatchTable['Rock'].Invoke; // or DispatchTable['Rock'](); 
    finally 
    DispatchTable.Free; 
    end; 
end. 

L'implementazione che ho scritto utilizza i generici in modo che funzionasse solo con Delphi 2009+. Per le versioni precedenti sarebbe probabilmente più semplice implementare utilizzando TStringList e command pattern

Answer 5

Non hai specificato la tua versione Delphi, tuttavia se hai Delphi 2010 (+) puoi farlo usando il RTTI avanzato, non lo sono esperto di loro, ma ho provato questo campione per voi:

TProcClass = class 
    public 
     procedure SayHi; 
     function GetSum(X,Y:Integer): Integer; 
    end; 

uses 
    Rtti; 

{ TProcClass } 

procedure TProcClass.SayHi; 
begin 
    ShowMessage('Hi'); 
end; 

function TProcClass.GetSum(X, Y: Integer): Integer; 
begin 
    ShowMessage(IntToStr(X + Y)); 
end; 

procedure ExecMethod(MethodName:string; const Args: array of TValue); 
var 
R : TRttiContext; 
T : TRttiType; 
M : TRttiMethod; 
begin 
    T := R.GetType(TProcClass); 
    for M in t.GetMethods do 
    if (m.Parent = t) and (m.Name = MethodName)then 
     M.Invoke(TProcClass.Create,Args) 
end; 

procedure TForm1.FormCreate(Sender: TObject); 
begin 
    ExecMethod('SayHi',[]); 
    ExecMethod('GetSum',[10,20]); 
end; 

Le buone cose, se si dispone di procedura o funzione con parametri che funzionerà senza più lavoro.

Answer 6

con Delphi 2010 è la utilizza JSON e SuperObject per richiamare il metodo con parametters.

http://code.google.com/p/superobject/source/browse/#svn/trunk

Se avete bisogno, c'è anche un parser XML per trasformare xml a JSON.

TForm1 = class(TForm) 
    Button1: TButton; 
    procedure Button1Click(Sender: TObject); 
    private 
    { Private declarations } 
    public 
    { Public declarations } 
    procedure TestMethod(const value: string); 
    end; 

var 
    Form1: TForm1; 

implementation 
uses superobject; 

{$R *.dfm} 

procedure TForm1.Button1Click(Sender: TObject); 
begin 
    SOInvoke(Self, 'TestMethod', SO('{value: "hello"}')); 
end; 

procedure TForm1.TestMethod(const value: string); 
begin 
    Caption := value; 
end; 

Answer 7

Inserire ciascuna funzione in un'azione. Quindi è possibile trovare l'Azione per nome ed eseguirlo

function ExecuteActionByName(const S: String); 
var 
    I: Integer; 
begin 
    for I := 0 to MainForm.ComponentCount-1 do 
    if (MainForm.Components[I] is TAction) 
    and SameText(TAction(MainForm.Components[I]).Name,S) then 
    begin 
     TAction(MainForm.Components[I]).Execute; 
     Break; 
    end; 
end; 

Answer 8

OK, io sono molto in ritardo alla festa, ma si può sicuramente chiamare le routine per nome con questo codice (Ci sono alcune limitazioni pensiero)

type 
    TExec = procedure of Object; 
    // rest of section... 

procedure TMainForm.ExecuteMethod(MethodName : String); 
var 
    Exec : TExec; 
    Routine : TMethod; 
begin 
    Routine.Data := Pointer(Form1); 
    Routine.Code := Form1.MethodAddress(MethodName); 
    if Not Assigned(Routine.Code) then 
     Exit; 

    Exec   := TExec(Routine); 
    Exec; 
end; 

Solo nel caso qualcuno ha bisogno di questo per Delphi 7/2010