delphi – 如何在方法指针中存储接口方法？

有一个例子：

type
  TDelegate = procedure of object;

  I1 = interface
  ['{31D4A1C7-668B-4969-B043-0EC93B673569}']
    procedure P1;
  end;

  TC1 = class(TInterfacedobject,I1)
    procedure P1;
  end;

...

var
  obj: TC1;
  int: I1;
  d: TDelegate;
begin
  obj := TC1.Create;
  ...
  int := obj; // "int" may contains TSomeAnotherObjectWhichImplementsI1
  d := obj.P1; // <- that's fine
  d := int.P1; // <- compiler error
end;

那我怎么做最后一次操作呢？
我不知道哪个类型的对象将出现在“int”变量中,所以我不能使用类型转换.但我知道它会出现什么(因为如果你实现了一个接口,你必须实现它的所有方法).那么为什么我不能只获得指向这种方法的指针呢？也许有另一种方式？
谢谢.

解决方法

Maybe there is another way?

最好的方法是更改​​期望TDelegate也接受i1的代码.如果您编写代码,那么更改是微不足道的,而且它基本上是您可以做的最好的.如果您无法更改期望TDelegate的代码,并且您绝对需要从接口调用该过程,则可能需要创建一个适配器对象,如下所示：

TDelegateAdapter = class
private
  Fi1: i1;
public
  constructor Create(Ani1: i1);

  procedure P;
end;

constructor TDelegateAdapter.Create(Ani1: i1);
begin
  Fi1 := Ani1;
end;

procedure TDelegateAdapter.P;
begin
  Fi1.P1;
end;

然后在需要分配TDelegate的代码中,执行以下操作：

var Adapter: TDelegateAdapter;
    Intf: i1; // assumed assigned
    ObjectExpectingDelegate: TXObject; // assumed assigned
begin
  Adapter := TDelegateAdapter.Create(Intf);
  try
    ObjectExpectingDelegate.OnSomething := Adapter.P;
    try
      ObjectExpectingDelegate.PerformWork;
    finally ObjectExpectingDelegate.OnSomething := nil;
    end;
  finally Adapter.Free;
  end;
end;

编辑

如果您使用的是支持匿名方法的Delphi版本,则可以使用此类匿名方法实现Delegate适配器,每个过程签名只需要一个“适配器”. Delphi使用Interfaces在幕后实现匿名方法,因此运行时性能很好,无需担心.

下面的代码是匿名委托适配器的演示控制台实现.直接看看最后的开始 – 结束块,看看魔术.

program Project29;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type

  // This is the type of the anonymous method I want to use
  TnoparamsProc = reference to procedure;

  // This implements the "delegate" adapter using an anonymous method
  TAnonymousDelegateAdapter = class
  private
    noparamsProc: TnoparamsProc;
  public
    constructor Create(anoparamsProc: TnoparamsProc);

    procedure AdaptedDelegate;
  end;

  { TAnonymousDelegateAdapter }

  procedure TAnonymousDelegateAdapter.AdaptedDelegate;
  begin
    noparamsProc;
  end;

  constructor TAnonymousDelegateAdapter.Create(anoparamsProc: TnoparamsProc);
  begin
    noparamsProc := anoparamsProc;
  end;

  // --------- test code follows ----------

type

  // Interface defining a single method.
  ISomething = interface
    procedure Test;
  end;

  // Implementation of the interface above
  TSomethingImp = class(TInterfacedobject,ISomething)
  public
    procedure Test;
  end;

  // DeFinition of delegate
  TnoparamsDelegate = procedure of object;

  { TSomethingImp }

  procedure TSomethingImp.Test;
  begin
    WriteLn('Test');
  end;

// ---- Test program to see it all in action. ---

var intf: ISomething;
    Dlg: TnoparamsDelegate;

begin
  intf := TSomethingImp.Create;
  // Here I'll create the anonymous delegate adapter,notice the "begin - end"
  // in the constructor call; That's the anonymous method. Runtime performance
  // of anonymous methods is very good,so you can use this with no warries.
  // My anonymous method uses the "intf" variable and calls the method "Test"
  // on it. Because of that the "intf" variable is "captured",so it doesn't run
  // out of scope as long as the anonymous method itself doesn't run out of scope.
  // In other words,you don't risk having your interface freed because it's reference
  // count reaches zero. If you want to use an other interface,replace the code
  // in the begin-end.
  with TAnonymousDelegateAdapter.Create(procedure begin intf.Test; end) do
  try
    Dlg := AdaptedDelegate;
    Dlg;
  finally Free;
  end;

  Readln;
end.