为接口引入附加名称时，从接口到类的转换失败 - 为什么？

Question

我偶然发现了一种情况，在某些情况下，从接口到类的硬转换会失败。

考虑以下类型定义：

  IDummy<T> = interface
  end;
  TMyRecord = record
    Intf:IDummy<Byte>;
  end;
  TDummy = class(TInterfacedObject, IDummy<Byte>)
  public
  end;

  IThisBreaksIt = IDummy<Byte>; // <== this line triggers the error

现在是使用这些类型的简单代码：

var
  ARecord:TMyRecord;
  Item:IDummy<Byte>;

  ImplWorks,
  ImplBroken:TDummy;
begin
  ARecord.Intf:=TDummy.Create;
  Item:=ARecord.Intf;

  ImplWorks:=TDummy(Item);
  ImplBroken:=TDummy(ARecord.Intf); // <== resulting instance is broken
end;

所以我正在做的是将接口引用存储在记录内。现在我想通过硬转换将其返回到实现类。

问题是：如果我为接口定义别名 (IThisBreaksIt = IDummy)，则会失败。注释掉这一行，ImplBroken 就不再损坏了。在损坏的情况下，ImplWorks 和 ImplBroken 的地址是不同的；相反，Item 和 ImplBroken 的地址现在是相同的。似乎负责硬转换的 automagic 无法启动。

其他发现：用 ARecord.Intf 替换 TDummy(ARecord.Intf) 作为 TDummy 修复了它。

这让我有些头疼，因为它被埋在一堆代码中，而我没想到会出现这种行为。这是正常的吗？

Cosmin 编辑：

将接口硬转换为对象的示例。

在XE中测试：有效（StreamAdaptIntf和StreamAdaptImpl的指针不同；断言成功） 2009年测试：失败（StreamAdaptIntf和StreamAdaptImpl的指针相同；断言失败）

uses ActiveX;

var
  Stream:TStream;
  StreamAdaptIntf:IStream;
  StreamAdaptImpl:TStreamAdapter;
begin
  Stream:=TMemoryStream.Create;
  StreamAdaptIntf:=TStreamAdapter.Create(Stream, soOwned);

  StreamAdaptImpl:=TStreamAdapter(StreamAdaptIntf);
  Assert(Integer(StreamAdaptImpl) <> Integer(StreamAdaptIntf));
end;

Answer 1

这可能没有帮助，这个问题很久以前就被问过，但是对于将来检查这个问题的任何人来说...

您可能刚刚发布了测试代码，但您的界面应该包含一个 GUID，GUID 唯一定义了编译器的接口（Ctrl在 Delphi 2009 中为 +Shift+G）。

IDummy<T> = interface
  ['{F9EF740B-FF23-465A-A2E0-E2ACD5ABD90F}']
  procedure DoSomething;
end;

硬铸造通常是不安全的。只有当您知道对象类型正确时，硬转换才是真正可以接受的。最好在进行强制转换时在强制转换之前检查其类型，如下所示...

var
  lTypeA: TTypeA;
begin
  if ObjectA is TTypeA then begin
    lTypeA := TTypeA(ObjectA);
  end;

更好的是，我会执行“as”强制转换，我认为如果它无效，这会导致异常。这确实是更好的选择！我编写了执行硬强制转换的代码，只是为了花几个小时才发现我的强制转换实际上是错误的...Delphi 不会告诉你是否强制转换为错误的类型，然后当你稍后使用该对象时，你最终会得到结果在整个调试噩梦中。 as 会引发异常并引导您解决代码中的问题，

var
  lTypeA: TTypeA;
begin
  if ObjectA is TTypeA then begin
    // Will raise an exception if ObjectA is not TTypeA, 
    // in this simple case the ObjectA is TTypeA test is redundant
    lTypeA := ObjectA as TTypeA;
  end;

我实际上只在 delphi 中的对象之间进行转换。 Delphi 有一个有用的函数“supports”，它将确定一个对象是否实现了一个接口并返回该接口的一个实例。然后，您可以使用返回的局部变量来执行接口

if Supports(ImplBroken, IThisBreaksIt, lObjInterface) then
begin
  lObjInterface.DoSomething;
end;

代码中所需的任何功能。

type
  // Generic IDummy interface
  IDummy<T> = interface
    ['{F9EF740B-FF23-465A-A2E0-E2ACD5ABD90F}']
    procedure DoSomething;
  end;

// Don't alias interfaces if possible
// This is a more specific version of your interface
IThisBreaksIt = interface(IDummy<Byte>)
  ['{76EFA371-4674-4190-8A4B-06850103C1D8}']
end;

TMyRecord = record
  // I would suggest, if you can avoid it don't store interfaces 
  // in a record, just simple types - just my opinion, delphi doesn't stop you
  Intf: IDummy<Byte>;
end;

// Remember this is interfaced, so the object only exists while refcount > 0
TDummy = class(TInterfacedObject, IDummy<Byte>)
protected
  { IDummy<T> }
  // interface methods should be protected
  // So ideally we refer to the interface of this object, 
  // not publicly available methods
  procedure DoSomething;
public
end;


var
  ARecord: TMyRecord;
  Item: IDummy<Byte>; // Think this should be IThisBreaksIt

  ImplWorks:TDummy;
  ImplBroken: IThisBreaksIt;
  lObjInterface: IThisBreaksIt;
begin
  ARecord.Intf := TDummy.Create;
  Item := ARecord.Intf;

  // Nasty hard cast here - what if your interfaced object is destroyed
  // before you reach this code section?
  ImplWorks := TDummy(Item);

  // This line compiles, buts it's really not the right way to get the interface
  ImplBroken := IThisBreaksIt(ARecord.Intf);

  // I believe this is the right way to get the interface for an object
  if Supports(ARecord.Intf, IThisBreaksIt, lObjInterface) then
  begin
    lObjInterface.DoSomething;
  end;
end;