Generischen Typ "merken" zur späteren Verwendung

[jaenicke]

Ein schnelles Beispiel, ungetestet:

Delphi-Quellcode:

uses
  Rtti;

type
  TMyRecord<T> = record
    Value: T;
  end;

  TMyRunner = reference to procedure;

  TFormXY = class(TForm)
  public
    procedure MyCallProc<T>(const Value: TMyRecord<T>);
  end;

var
  FormXY: TFormXY;

implementation

procedure AddToQueue1(const AQueue: TQueue<TMyRunner>);
var
  MyRecord: TMyRecord<Integer>;
begin
  MyRecord.Value := 1002;
  AQueue.Enqueue(procedure
    begin
      FormXY.MyCallProc<Integer>(MyRecord);
    end);
end;

procedure AddToQueue2(const AQueue: TQueue<TMyRunner>);
var
  MyRecord: TMyRecord<string>;
begin
  MyRecord.Value := 'Oh, ein String!';
  AQueue.Enqueue(procedure
    begin
      FormXY.MyCallProc<string>(MyRecord);
    end);
end;

procedure TFormXY.FormCreate(Sender: TObject);
var
  ExampleQueue: TQueue<TMyRunner>;
begin
  ExampleQueue := TQueue<TMyRunner>.Create;
  try
    AddToQueue1(ExampleQueue);
    AddToQueue2(ExampleQueue);
    while ExampleQueue.Count > 0 do
      ExampleQueue.Dequeue.Invoke;
  finally
    ExampleQueue.Free;
  end;
end;

procedure TFormXY.MyCallProc<T>(const Value: TMyRecord2<T>);
begin
  if TypeInfo(T) = TypeInfo(Integer) then
    ShowMessage(IntToStr(TValue.From<T>(Value.Value).AsType<Integer>))
  else if TypeInfo(T) = TypeInfo(String) then
    ShowMessage(TValue.From<T>(Value.Value).AsType<String>)
  else
    //...
end;

Nicht sauber geschrieben, aber sollte so gehen und zeigen wie ich das meinte.

[RSE]

Ah, der Kern deiner Idee ist also folgender: Die asynchron aufzurufende Methode mit generischen Parametern wird in eine parameterlose anonyme Funktion verpackt, die nichts anderes tut, als die asynchron aufzurufende Methode mit den passenden Parametern aufzurufen. Im Kontext dieser parameterlosen anonymen Funktion sind die tatsächlichen Typen der generischen Parameter der asynchron aufzurufenden Methode bekannt und deshalb kann sie auch aufgerufen werden. Beim Empfang der Windows-Message brauche ich die Infos über die generischen Typen gar nicht, da ich nur die anonyme Funktion aufrufe (im "alten" Kontext).

Mein angepasster Quelltext:

Delphi-Quellcode:

  TAsync = class
  public
    type
      TAsyncProc = reference to procedure;
      TAsyncProc1<T1> = reference to procedure(P1: T1);
    class procedure Call(Proc: TAsyncProc); overload;
    class procedure Call<T1>(Proc: TAsyncProc1<T1>; P1: T1); overload;
  private
    const
      WM_ASYNCCALLINVOKE = WM_USER + $4df8;
    class function AsyncCallInvoke(var m: TMessage): Boolean;
  end;

...

implementation

...


class function TAsync.AsyncCallInvoke(var m: TMessage): Boolean;
var
  PProc: ^TAsyncProc;
begin
  case m.Msg of
    WM_ASYNCCALLINVOKE:
      begin
        Result := True;
        case m.WParam of
          0:
            begin
              PProc := Pointer(m.LParam);
              try
                PProc^.Invoke;
              finally
                Dispose(PProc);
              end;
            end;
        end;
      end;
    else
      Result := False;
  end;
end;

class procedure TAsync.Call(Proc: TAsyncProc);
var
  PProc: ^TAsyncProc;
begin
  MessageDistributor.RegisterMessageHandlerMethod(TAsync.AsyncCallInvoke);
  New(PProc);
  PProc^ := Proc;
  PostMessage(MessageDistributor.Handle, WM_ASYNCCALLINVOKE,
              0, Integer(PProc));
end;

class procedure TAsync.Call<T1>(Proc: TAsyncProc1<T1>; P1: T1);
var
  PProc: ^TAsyncProc;
begin
  MessageDistributor.RegisterMessageHandlerMethod(TAsync.AsyncCallInvoke);
  New(PProc);
  PProc^ := procedure
    begin
      Proc(P1);
    end;
  PostMessage(MessageDistributor.Handle, WM_ASYNCCALLINVOKE,
              0, Integer(PProc));
end;

Vielen Dank für diese Idee!