delphi - 如何将接口(interface)方法存储在方法指针中？

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

Answer 1

Maybe there is another way?

最好的方法是更改​​期望 TDelegate 也接受 i1 的代码。如果您编写了代码，则更改是微不足道的，并且基本上是您能做的最好的事情。如果您无法更改期望 TDelegate 的代码，并且您绝对需要从接口(interface)调用该过程，则您可能需要创建一个适配器对象，如下所示:

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使用接口(interface)在幕后实现匿名方法，因此运行时性能会很好，无需担心。

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

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.