Aufrufen einer Unterprozedur mit AsyncCalls

[Benmik]

Ich habe eine Prozedur mit Unterprozeduren:

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.

[Sir Rufo]

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

[Benmik]

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;

[Sir Rufo]

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

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)

[Uwe Raabe]

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

Z.B. diese

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.

[Sir Rufo]

Dann kann man die ja als overload noch hinzufügen

[Benmik]

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???

[Sir Rufo]

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

Delphi-Quellcode:

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

Jetzt klar?

[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.

[Sir Rufo]

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