Delphi：如何将接口实现委托给子对象？

Question

我有一个对象，它将一个特别复杂的接口的实现委托给子对象。我认为这个 正是 是 TAggreatedObject 的工作。 “子”对象维护对其“控制器”的弱引用，并且所有 QueryInterface< /code> 请求被传递回父级。这维持了 IUnknown 的规则 始终是同一个对象。

因此，我的父对象（即“Controller”）声明它实现了 IStream 接口：

type
   TRobot = class(TInterfacedObject, IStream)
   private
      function GetStream: IStream;
   public
      property Stream: IStream read GetStrem implements IStream;
   end;

注意：这是一个假设的示例。我选择了“机器人”这个词 因为这听起来很复杂，并且 这个词只有 5 个字母长 - 它是 短的。我还选择了 IStream 因为 它很短。我本来打算用 IPersistFile 或 IPersistFileInit， 但它们更长，并且使 示例代码更难真实。在其他方面 单词：这是一个假设的例子。

现在我有了将实现 IStream 的子对象：

type
   TRobotStream = class(TAggregatedObject, IStream)
   public
      ...
   end;

剩下的就是我的问题开始的地方：在要求时创建 RobotStream：

function TRobot.GetStream: IStream;
begin
    Result := TRobotStream.Create(Self) as IStream;
end;

此代码无法编译，出现错误运算符不适用于此操作数类型。。

这是因为 delphi 试图在未实现 IUnknown 的对象上执行 as IStream：

TAggregatedObject = class
 ...
   { IUnknown }
   function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
   function _AddRef: Integer; stdcall;
   function _Release: Integer; stdcall;
 ...

IUnknown 方法 可能存在，但该对象不会宣传它支持IUnknown。如果没有 IUnknown 接口，Delphi 就无法调用 QueryInterface 来执行转换。

因此，我更改了我的 TRobotStream 类来宣传它实现了缺少的接口（它确实实现了；它从其祖先继承了它）：

type
   TRobotStream = class(TAggregatedObject, IUnknown, IStream)
   ...

现在它可以编译，但在运行时崩溃：

Result := TRobotStream.Create(Self) as IStream;

现在我可以看看发生了什么，但我无法解释为什么。 Delphi 在子对象的构造函数中调用父 Robot 对象上的 IntfClear。

我不知道防止这种情况的正确方法。我可以尝试强制演员表：

Result := TRobotStream.Create(Self as IUnknown) as IStream;

并希望保留一个参考。事实证明，它确实保留了引用——在构造函数之外没有崩溃。

注意：这让我感到困惑。因为我正在传递一个对象，其中 预计会有一个界面。我会 假设编译器是隐式的 执行类型转换，即：

Result := TRobotStream.Create(Self as IUnknown);

为了满足召唤。这 事实上语法检查器没有 抱怨让我假设一切都是 正确。

---

但崩溃还没有结束。我已将该行更改为：

Result := TRobotStream.Create(Self as IUnknown) as IStream;

并且代码确实从 TRobotStream 的构造函数返回，而不破坏我的父对象，但现在我遇到了堆栈溢出。

原因是 TAggreatedObject 将所有 QueryInterface（即类型转换）推迟回父对象。就我而言，我将 TRobotStream 转换为 IStream。

当我在末尾向 TRobotStream 询问其 IStream 时：

Result := TRobotStream.Create(Self as IUnknown) as IStream;

它转身向其控制器询问 IStream > 接口，它触发对：的调用：

Result := TRobotStream.Create(Self as IUnknown) as IStream;
   Result := TRobotStream.Create(Self as IUnknown) as IStream;

它转身并调用：

Result := TRobotStream.Create(Self as IUnknown) as IStream;
   Result := TRobotStream.Create(Self as IUnknown) as IStream;
      Result := TRobotStream.Create(Self as IUnknown) as IStream;

Boom！堆栈溢出。

---

盲目地，我尝试删除对IStream，让 Delphi 尝试将对象隐式转换为接口（我刚刚在上面看到的不起作用）：

Result := TRobotStream.Create(Self as IUnknown);

现在没有崩溃；我不太明白这一点。我构造了一个对象，一个支持多个接口的对象。现在 Delphi 知道如何转换接口了吗？它是否执行正确的引用计数？我在上面看到它没有。是否有一个微妙的错误等待着客户崩溃？

所以我只剩下四种可能的方式来拨打我的专线。其中哪一个是有效的？

1. 结果 := TRobotStream.Create(Self);
2. 结果 := TRobotStream.Create(Self as IUnknown);
3. 结果 := TRobotStream.Create(Self) as IStream ;
4. Result := TRobotStream.Create(Self as IUnknown) as IStream;

真正的问题

我遇到了很多微妙的错误，并且很难理解编译器的复杂性。这让我相信我所做的一切都是完全错误的。如果需要的话，请忽略我所说的一切，并帮助我回答问题：

将接口实现委托给子对象的正确方法是什么？

也许我应该使用 TContainedObject 而不是 TAggreatedObject。也许两者协同工作，其中父级应该是 TAggreatedObject，子级是 TContainedObject。也许恰恰相反。也许两者都不适用于这种情况。

注意：我帖子主要部分中的所有内容都可以忽略。这只是 以表明我已经考虑过它。 有人会认为 通过包括我尝试过的内容，我已经 毒害了可能的答案；相当 而不是回答我的问题，人们 可能会关注我失败的问题。

真正的目标是委托接口 子对象的实现。这 问题包含我的详细尝试 在解决问题时 TAggregatedObject。你甚至不 请参阅我的另外两个解决方案模式。 其中之一患有圆形 引用计数，并且打破了 IUnknown 等价规则。

罗布·肯尼迪可能还记得；并询问 我提出一个问题，要求 解决问题的方法，而不是 解决我的一个问题 解决方案。

编辑：语法化

编辑2：没有机器人控制器这样的东西。嗯，有 - 我一直使用 Funuc RJ2 控制器。但在这个例子中不是这样！

编辑 3*

  TRobotStream = class(TAggregatedObject, IStream)
    public
        { IStream }
     function Seek(dlibMove: Largeint; dwOrigin: Longint;
        out libNewPosition: Largeint): HResult; stdcall;
     function SetSize(libNewSize: Largeint): HResult; stdcall;
     function CopyTo(stm: IStream; cb: Largeint; out cbRead: Largeint; out cbWritten: Largeint): HResult; stdcall;
     function Commit(grfCommitFlags: Longint): HResult; stdcall;
     function Revert: HResult; stdcall;
     function LockRegion(libOffset: Largeint; cb: Largeint; dwLockType: Longint): HResult; stdcall;
     function UnlockRegion(libOffset: Largeint; cb: Largeint; dwLockType: Longint): HResult; stdcall;
     function Stat(out statstg: TStatStg; grfStatFlag: Longint): HResult; stdcall;
     function Clone(out stm: IStream): HResult; stdcall;

     function Read(pv: Pointer; cb: Longint; pcbRead: PLongint): HResult; stdcall;
     function Write(pv: Pointer; cb: Longint; pcbWritten: PLongint): HResult; stdcall;
  end;

  TRobot = class(TInterfacedObject, IStream)
  private
      FStream: TRobotStream;
      function GetStream: IStream;
  public
     destructor Destroy; override;
      property Stream: IStream read GetStream implements IStream;
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.Button1Click(Sender: TObject);
var
    rs: IStream;
begin
    rs := TRobot.Create;
    LoadRobotFromDatabase(rs); //dummy method, just to demonstrate we use the stream
    rs := nil;
end;

procedure TForm1.LoadRobotFromDatabase(rs: IStream);
begin
    rs.Revert; //dummy method call, just to prove we can call it
end;

destructor TRobot.Destroy;
begin
  FStream.Free;
  inherited;
end;

function TRobot.GetStream: IStream;
begin
  if FStream = nil then
     FStream := TRobotStream.Create(Self);
  result := FStream;
end;

这里的问题是“父”TRobot 对象在调用期间被销毁：

FStream := TRobotStream.Create(Self);

Answer 1

您必须为创建的子对象添加一个字段实例：

type
  TRobot = class(TInterfacedObject, IStream)
  private
     FStream: TRobotStream;
     function GetStream: IStream;
  public
     property Stream: IStream read GetStream implements IStream;
  end;

destructor TRobot.Destroy;
begin
  FStream.Free; 
  inherited; 
end;

function TRobot.GetStream: IStream;
begin
  if FStream = nil then 
    FStream := TRobotStream.Create(Self);
  result := FStream;
end;

更新
正如您已经猜到的那样，TRobotStream 应该派生自 TAggregateObject。声明应该是：

type
  TRobotStream = class(TAggregatedObject, IStream)
   ...
  end;

没有必要提及 IUnknown。

在 TRobot.GetStream 中，result := FStream 行隐式执行 FStream as IStream，因此也没有必要将其写出。

FStream 必须声明为 TRobotStream 而不是 IStream，因此它可以在 TRobot 实例被销毁时被销毁。注意：TAggregatedObject 没有引用计数，因此容器必须注意其生命周期。

更新（Delphi 5 代码）：

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, activex, comobj;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    procedure Button1Click(Sender: TObject);
  private
    procedure LoadRobotFromDatabase(rs: IStream);
  public
  end;

type
  TRobotStream = class(TAggregatedObject, IStream)
  public
    { IStream }
    function Seek(dlibMove: Largeint; dwOrigin: Longint;
       out libNewPosition: Largeint): HResult; stdcall;
    function SetSize(libNewSize: Largeint): HResult; stdcall;
    function CopyTo(stm: IStream; cb: Largeint; out cbRead: Largeint; out cbWritten: Largeint): HResult; stdcall;
    function Commit(grfCommitFlags: Longint): HResult; stdcall;
    function Revert: HResult; stdcall;
    function LockRegion(libOffset: Largeint; cb: Largeint; dwLockType: Longint): HResult; stdcall;
    function UnlockRegion(libOffset: Largeint; cb: Largeint; dwLockType: Longint): HResult; stdcall;
    function Stat(out statstg: TStatStg; grfStatFlag: Longint): HResult; stdcall;
    function Clone(out stm: IStream): HResult; stdcall;
    function Read(pv: Pointer; cb: Longint; pcbRead: PLongint): HResult; stdcall;
    function Write(pv: Pointer; cb: Longint; pcbWritten: PLongint): HResult; stdcall;
  end;

type
  TRobot = class(TInterfacedObject, IStream)
  private
    FStream: TRobotStream;
    function GetStream: IStream;
  public
    destructor Destroy; override;
    property Stream: IStream read GetStream implements IStream;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  rs: IStream;
begin
  rs := TRobot.Create;
  LoadRobotFromDatabase(rs); //dummy method, just to demonstrate we use the stream
  rs := nil;
end;

procedure TForm1.LoadRobotFromDatabase(rs: IStream);
begin
  rs.Revert; //dummy method call, just to prove we can call it
end;

function TRobotStream.Clone(out stm: IStream): HResult;
begin
end;

function TRobotStream.Commit(grfCommitFlags: Integer): HResult;
begin
end;

function TRobotStream.CopyTo(stm: IStream; cb: Largeint; out cbRead, cbWritten: Largeint): HResult;
begin
end;

function TRobotStream.LockRegion(libOffset, cb: Largeint; dwLockType: Integer): HResult;
begin
end;

function TRobotStream.Read(pv: Pointer; cb: Integer; pcbRead: PLongint): HResult;
begin
end;

function TRobotStream.Revert: HResult;
begin
end;

function TRobotStream.Seek(dlibMove: Largeint; dwOrigin: Integer;
  out libNewPosition: Largeint): HResult;
begin
end;

function TRobotStream.SetSize(libNewSize: Largeint): HResult;
begin
end;

function TRobotStream.Stat(out statstg: TStatStg; grfStatFlag: Integer): HResult;
begin
end;

function TRobotStream.UnlockRegion(libOffset, cb: Largeint; dwLockType: Integer): HResult;
begin
end;

function TRobotStream.Write(pv: Pointer; cb: Integer; pcbWritten: PLongint): HResult;
begin
end;

destructor TRobot.Destroy;
begin
  FStream.Free;
  inherited;
end;

function TRobot.GetStream: IStream;
begin
  if FStream = nil then
     FStream := TRobotStream.Create(Self);
  result := FStream;
end;

end.

Answer 2

进行委托的类不需要从任何特定类继承。如果已实现适当的方法，您可以从 TObject 继承。我将保持简单并使用 TInterfacedObject 进行说明，它提供了您已经确定的 3 个核心方法。

另外，您不需要 TRobotStream = class(TAggreatedObject, IUnknown, IStream)。您可以简单地声明 IStream 继承自 IUnknown。顺便说一句，我总是给我的界面一个 GUID（按组合键 Ctrl+Shift+G）。

根据您的特定需求，可以应用多种不同的方法和技术。

• 委托给接口类型
• 委托给类 类型
• 方法别名

最简单的委托是通过接口。

TRobotStream = class(TinterfacedObject, IStream)

TRobot = class(TInterfacedObject, IStream)
private
  //The delegator delegates the implementations of IStream to the child object.
  //Ensure the child object is created at an appropriate time before it is used.
  FRobotStream: IStream;
  property RobotStream: IStream read FRobotStream implements IStream;
end;

也许有一些事情需要注意：

• 确保您委托的对象具有适当的生命周期。
• 请务必保留受委托者的参考信息。请记住，接口是有引用计数的，一旦计数降至零，接口就会被销毁。 这实际上可能是您头痛的原因。