Aufrufen einer Unterprozedur mit AsyncCalls

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

[Benmik]

Zitat von Sir Rufo:

Jetzt klar?

Leider nein...
Ich habe mal Folgendes probiert:

Delphi-Quellcode:

procedure TForm1.Haupt;
type 
  TTuWas = reference to function(i:integer):integer;
var TuWas:TTuWas ;
  //-------------------------------------------------------
  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;

Der Compiler meint "Es gibt keine überladene Version usw....")
Abgesehen davon, dass TuWas ja noch fehlt, schreit er jetzt schon. Das ist es ja, wie geht sowas?

[Sir Rufo]

Weil der Typ nicht passt.

Delphi-Quellcode:

var
  TuWas: TAsyncCallArgGenericMethod<Integer>;

[Benmik]

Oh je, wenn mal Uwe nicht Recht behält...
Sir Rufos Vorschlag wird auch nicht gnädig behandelt, da die Deklaration private ist...
Ich hänge die Datei mal an.

[Sir Rufo]

Wenn man keine Rücksicht auf Abwärtskompatibilität legen muss, dann kann man alles in eine normale anonyme Methode packen:

Delphi-Quellcode:

TAnonWrapper = class
  class function Wrap<T>( AProc: TProc<T>; Arg: T ) : TProc;
  class function Wrap<T,TResult>( AFunc: TFunc<T,TResult>; Arg: T ) : TFunc<TResult>;
  // das kann man jetzt mit beliebig vielen Argumenten weiterspinnen
end;

class function TAnonWrapper.Wrap<T>( AProc: TProc<T>; Arg: T ) : TProc;
begin
  Result := 
    procedure ()
    begin
      AProc( Arg );
    end;
end;

class function TAnonWrapper.Wrap<T,TResult>( AFunc: TFunc<T,TResult>; Arg: T ) : TFunc<TResult>;
begin
  Result :=
    function(): TResult
    begin
      Result := AFunc( Arg );
    end;
end;

Man kann sich also das gesamte Interface-Implementierungs-Boilerplate-Geraffel komplett sparen und alles euf einen gemeinsamen Typen herunterbrechen.

Und wenn ich nur noch eins implementieren muss, dann ist das halt weniger.

[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