实现多个接口的类的清晰度（替代委托）：

Question

假设我们有以下内容：

IFirst = Interface(IUnknown)    
  function GetStuff: Integer;
end;
    
ISecond = Interface(IUnknown)
  function GetOtherStuff: Integer;
end;
    
TFirstSecond = class(TInterfacedObject, IFirst, ISecond)    
private 
  function GetStuff: Integer;        //implementation of IFirst
  function GetOtherStuff: Integer;   //implementation of ISecond;
end;

我从来不喜欢这样一个事实：在 TInterfacedObject 中似乎无法区分哪些方法实现哪些接口。我错过了什么吗？有谁知道如何构造代码来做到这一点？指定GetStuff是IFirst的实现，而GetOtherStuff是ISecond的实现？ （“发表评论”不是我正在寻找的答案...）

我知道我可以使用“implements”指令为每个接口在 TFirstSecond 中定义属性并将实现委托给实例包含在 TFirstSecond 中，从而隔离一切。但我想要一条捷径...

Answer 1

我想您在不使用注释的情况下真正可以做的唯一一件事就是添加方法解析子句：

IFirst = interface
  function GetStuff: Integer;
end;

ISecond = interface
  function GetOtherStuff: Integer;
end;

TFirstSecond = class(TInterfacedObject, IFirst, ISecond)
private
  function GetStuff: Integer;
  function GetOtherStuff: Integer;
public
  function IFirst.GetStuff = GetStuff;
  function ISecond.GetOtherStuff = GetOtherStuff;
end;

我不'我认为这确实增加了很多混合，我个人认为这比没有方法解析子句更糟糕。

Answer 2

在您发布的情况下，我也更喜欢评论（接口名称就像 NGLN 所说的那样），但我想解释为什么 implements 关键字在其他一些情况下可能是最佳解决方案，但不是在在简单的情况下，每个接口只有一种方法，就像您的简单示例一样。

我知道你说过你了解 Implements；但对于那些还没有看过它的人来说，我想记录一下它何时有用，请耐心等待。在某些情况下，开设更多课程的所有额外工作甚至是值得的。

因此，我不会使用实现作为快捷方式（如您所见，它更长！），而是仅当每个接口涉及 100 个要实现的方法，并且最终的设计具有更少的耦合、更好的内聚性和可读性时。

所以这确实是一个愚蠢的例子，但是如果 IFirst 和 ISecond 中的每一个都有 100 个方法，那么这可能是一个巨大的飞跃......

type
IFirst = interface
  function GetStuff: Integer;
end;

ISecond = interface
  function GetOtherStuff: Integer;
end;

TFirstLogic = class(TInterfacedObject, IFirst)
  function GetStuff: Integer;

end;

TSecondLogic = class(TInterfacedObject, ISecond)
  function GetOtherStuff: Integer;
end;

TFirstSecond = class(TInterfacedObject, IFirst, ISecond)
private
  FFirst:TFirstLogic;
  FSecond:TSecondLogic;
protected


  property First:TFirstLogic read FFirst implements IFirst;
  property Second:TSecondLogic read FSecond implements ISecond;
public
  constructor Create; // don't forget to create and free FFirst/FSecond.
  destructor Destroy; override; // don't forget to create and free FFirst/FSecond.


end;

你可以说 Implements 是我们可以做“部分类”的唯一方法，或者至少创建一个复合类，它实现了一堆接口，并且有一堆子属性（受保护的甚至可能是私有的）用于执行“实现”委托。如果您将其他所有内容都从包含聚合类的单元中移出，那么您可能会得到一个非常干净的设计。

Answer 3

虽然您特别要求不涉及注释的答案，但我可以说使用注释是不仅仅是 Delphi VCL 的常见解决方案，准确地说如下：

TFirstSecond = class(TInterfacedObject, IFirst, ISecond)
private
  { IFirst }
  function GetStuff: Integer;
private
  { ISecond }
  function GetOtherStuff: Integer;
end;

Answer 4

D2006（但也可能是更早的版本，D2006 只是我目前可用的最早的版本），支持接口方法到特定类函数的“映射”。这消除了像使用 implements 关键字那样拥有属性的必要性。

当两个接口包含相同的方法签名但需要不同的实现时，使用接口映射也应该是消除歧义的一种方法。

示例：

IMyFirstInterface = interface(IInterface)
  procedure DoSomethingInteresting;
  procedure DoSomethingElse;
end;

IMySecondInterface = interface(IInterface)
  procedure DoSomethingInteresting;
end;

TMyCombinedObject = class(TInterfacedObject, IMyFirstInterface, IMySecondInterface)
private
  // Interface mappings 
  procedure IMyFirstInterface.DoSomethingInteresting = DoSomethingInterestingFirst;
  procedure IMySecondInterface.DoSomethingInteresting = DoSomethingInterestingSecond;
protected
  procedure DoSomethingInterestingFirst;
  procedure DoSomethingInterestingSecond;
  procedure DoSomethingElse;
end;

如果您有大量接口或大量方法，则缺点是：重复。但是，正如您在示例中看到的，您不需要为接口中的所有方法指定映射。

出于文档目的，您可以将映射直接与实际方法声明放在一起，这样它们就可以保持在一起并且不太可能不同步（或者更确切地说，映射将错过新方法，因为您不需要为每个方法声明一个映射）接口方法）：

TMyCombinedObject = class(TInterfacedObject, IMyFirstInterface, IMySecondInterface)
protected
  procedure IMyFirstInterface.DoSomethingInteresting = DoSomethingInterestingFirst;
  procedure DoSomethingInterestingFirst;

  procedure IMySecondInterface.DoSomethingInteresting = DoSomethingInterestingSecond;
  procedure DoSomethingInterestingSecond;

  procedure DoSomethingElse;
end;