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

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

我想不使用 cmets 你唯一能做的就是添加method resolution clauses:

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

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

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

Answer 3

在您发布的情况下，我也更喜欢 cmets（接口名称正如 NGLN 所说），但我想解释一下为什么 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 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;