Aufrufen einer Unterprozedur mit AsyncCalls

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

[Benmik]

So leid es mir tut, beim Anblicken des Codes habe ich eine Ahnung, mehr aber auch nicht.
Wie gesagt, ich habe ja funktionierenden Code, ich möchte nur begreifen, wie man das geschilderte Problem löst.
Also ganz schlicht, der Teil

Delphi-Quellcode:

  //-------------------------------------------------------
  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;
  //-------------------------------------------------------

sähe dann wie aus?

Da wir schon beim Lernen sind, den Vorschlag

Delphi-Quellcode:

var
  TuWas: TAsyncCallArgGenericMethod<Integer>;

konnte ich nicht umsetzen da es mir nicht gelang, TAsyncCallArgGenericMethod sichtbar zu machen. Ich habe die Deklaration in AsyncCalls public gemacht, das hat den Compiler leider nicht interessiert.
Und wie sähe denn dann die Lösung aus?
Vielen Dank.

[Benmik]

Wie vielleicht der eine oder andere mitbekommen hat, habe ich die Frage noch einmal auf stackoverflow gestellt, da ich einfach nicht weiterkam. Das Ganze verlief mehr als unbefriedigend und endete mit einem Downvote von David Heffernan. Der jetzige Stand dort ist, dass mein Vorhaben nicht möglich ist.

Von der Diskussion hier habe ich zwei Dinge mitgenommen:

1. Es ist möglich
2. Aus pädagogischen Gründen liefern wir dir aber nicht die fertige Lösung

Und da bitte ich doch unsere Lords und Dukes hier, ihrem Herzen einen Stoß zu geben und zu zeigen, wie es geht. Weltweiter Dank wäre euch sicher.