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

Question

有一个例子：

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”变量中会出现哪种类型的对象，所以我不能使用类型转换。但我知道无论如何它会出现什么（因为如果你实现一个接口，你必须实现它的所有方法）。那么为什么我不能只得到一个指向这个方法的指针呢？也许还有另一种方式？ 谢谢。

Answer 1

也许还有其他方法？

最好的方法是更改​​期望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 版本，则可以使用此类匿名方法实现委托适配器，每个过程签名只需要一个“适配器”。 Delphi使用Interfaces在后台实现匿名方法，所以运行时性能会很好，不用担心。

下面的代码是匿名委托适配器的演示控制台实现。直接看看最后的 begin - end 块，看看它的魔力。

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.

Answer 2

我想编译器阻止它的至少一个原因是procedure of object 不是托管类型，因此您将绕过接口引用计数。

不允许这样做的另一个原因是接口方法的调用机制与procedure of object 的调用机制不同。

Answer 3

我会建议你可能不太可能的选项，但它正在切换到 freepascal/lazarus

我检查过，您的代码片段在那里编译并工作。