Does interface delegation of an inherited interface require a wrapper class?

Question

Delphi allows for interface delegation using the implements keyword.

For example

IIndep1 = interface
  function foo2: integer;
end;

IIn         


        

Answer 1

This looks like the compiler is attempting to enforce the expectations (read: requirements) of IUnknown.QueryInterface:

For any one object, a specific query for the IUnknown interface on any of the object's interfaces must always return the same pointer value.

If you were able to delegate the implementation of a base interface whilst implementing a derived interface yourself then:

obj := TLev2Fails.Create(otherLev1);  // Assuming your class could compile

lev1 := obj as ILev1;     // yields reference to otherLev1 implementor
lev2 := obj as ILev2;     // yields reference to TLev2Fails instance

unk1 := lev1 as IUnknown;   // returns IUnknown of otherLev1 implementor
unk2 := lev2 as IUnknown;   // returns IUnknown of obj TLev2fails instance

This would not be the case if your nested object were correctly implemented as a TAggregatedObject derived class, but the compiler has no way of knowing whether this is the case let alone enforcing it so instead it appears it simply requires that if you implement a derived interface then you must also directly implement any interfaces that interface itself inherits.

The compiler error in this situation isn't being very helpful, though it could be read as telling you what you need to do, just not why you need to do it in this case, which is not that unusual for compiler errors.

If you wish to delegate in this case then you must "delegate manually".

Whilst this loses the benefit of the implements facility, it does at least retain the benefits of re-use, just not quite as conveniently.

NOTE: Even if your delegated implementation is based on a TAggregatedObject, the compiler still cannot determine that these implementation details satisfies the requirements of QueryInterface so you will still get this error (even if using a class reference for the delegated interface).

You must still delegate manually.

Having said all that, I cannot currently see how this is any different for the case when interfaces are involved with no inheritance relationship, but it is quite possible that this is valid and I just haven't worked through all the necessary 'thought experiments' to prove it to myself. :)

It may be that the compiler is just being extra cautious in situations when it thinks it can/should be and the documentation simply fails to mention this resulting limitation of implements.

Or it may be a bug in the compiler, though I think there are sufficiently apparent reasons for the behaviour and the behaviour is itself so well established and consistent (having reproduced the exact same behaviour in Delphi 7) that an omission in relevant documentation is the more likely explanation.