Ich habe eine Prozedur mit Unterprozeduren:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.Haupt;
var i:integer;
  //-------------------------------------------------------
  function TuWas(i:integer):integer;
  begin
  end;
  //-------------------------------------------------------
  procedure RufeAuf;
  begin
    TAsyncCalls.Invoke(
      procedure
      var i:integer;
      begin
        For i := 0 to 10 do
          If i < 11
            then TAsyncCalls.Invoke<integer>(TuWas,i));
    end);
  end;
  //-------------------------------------------------------
begin
  RufeAuf;
end;

So, wie es da oben steht, funktioniert das natürlich nicht. In Wirklichkeit ist TuWas bei mir eine Klassenmethode von TForm1, und das funktioniert ohne Probleme. Ich hätte es aber aus rein codeökonomischen Gründen gern in einer Unterfunktion. Ich habe auch eine Ahnung, wie man das machen könnte, insbesondere von hier. Ich kriege es aber nicht hin, insbesondere nicht mit AsyncCalls. Ich bin mir aber sicher, dass das einige von euch nur ein müdes Lächeln kostet.

Was erwartet Invoke denn als Argument? Daran kann man sehen was geht und was nicht

zusammenfalten · markieren

Delphi-Quellcode:

class function Invoke<T>(Event: TAsyncCallArgGenericMethod<T>; const Arg: T): IAsyncCall; overload; static;

  IAsyncCall = interface
    { Sync() waits until the asynchronous call has finished and returns the
      result value of the called function if that exists. }
    function Sync: Integer;

    { Finished() returns True if the asynchronous call has finished. }
    function Finished: Boolean;

    { ReturnValue() returns the result of the asynchronous call. It raises an
      exception if called before the function has finished. }
    function ReturnValue: Integer;

    { ForceDifferentThread() tells AsyncCalls that the assigned function must
      not be executed in the current thread. }
    procedure ForceDifferentThread;

    { added by Zarko Gajic to support canceling tasks waiting in the ThreadPool queue}
    procedure Cancel;
  end;

TAsyncCallArgGenericMethod<T> = function(Arg: T): Integer of object;

Jo, dann gehen da nur Methoden rein - ob der Typ wohl deswegen TAsyncCallArgGenericMethod (bemerke Method) heißt?

Wenn du das ändern möchtest dann einfach

markieren

Delphi-Quellcode:

// TAsyncCallArgGenericMethod<T> = function(Arg: T): Integer of object;
TAsyncCallArgGenericMethod<T> = reference to function(Arg: T): Integer;

dann geht da alles rein.

(Den Namen muss man nicht ändern, sollte man aber)

Da Invoke als overload deklariert ist, gibt es doch sicher noch andere Möglichkeiten, oder?

Z.B. diese

markieren

Delphi-Quellcode:

    
      TAsyncCallArgGenericProc<T> = function(Arg: T): Integer;

class function Invoke<T>(Proc: TAsyncCallArgGenericProc<T>; const Arg: T): IAsyncCall; overload; static;

Das wäre dann die mit der globalen Function, wobei ich dann aber die Object Method vorziehen würde.

Leider gibt es aber keine mit reference to , weswegen der Ansatz aus dem SO Link nicht zieht.

Dann kann man die ja als overload noch hinzufügen

Da wollte ich auf Sir Rufo antworten:
"Sind anonyme Methoden nicht auch Methoden? Ich erinnere mich an Lösungen á la M:TMethod ."

... aber da waren mir die Ereignisse schon voraus. Also OK, ich haue TAsyncCallArgGenericMethod<T> = reference to function(Arg: T): Integer; rein, und dann???

Dann kannst du Methoden, Proceduren und anonyme Methoden übergeben.
reference to deckt alle drei Fälle ab.

markieren

Delphi-Quellcode:

TFooMethod = procedure of object; // NUR Methoden
TFooProc = procedure; // NUR Prozeduren
TFooAnon= reference to procedure; // Methoden, Prozeduren, Anonyme Methoden

Jetzt klar?

Zitat von Sir Rufo:

Dann kann man die ja als overload noch hinzufügen

Da die Entwicklung von AsyncCalls aktuell eingestellt ist, wäre das ein sinnvoller Ansatz. Ich fürchte nur, daß für die Implementierung noch ein bisschen mehr Boilerplate-Code erforderlich sein wird.

Zitat von Uwe Raabe:

Zitat von Sir Rufo:

Dann kann man die ja als overload noch hinzufügen

Da die Entwicklung von AsyncCalls aktuell eingestellt ist, wäre das ein sinnvoller Ansatz. Ich fürchte nur, daß für die Implementierung noch ein bisschen mehr Boilerplate-Code erforderlich sein wird.

Wenn die Anonymen dort noch gar nicht verwendet werden, dann wird es eher weniger