How to pass a list of objects to a function, which expects a list of objects which implement an inte-CodePudding

tl;dr:

Trying to pass a list of objects to a function, which expects list of objects implementing an interface. Said objects implement that interface. Compiler will not allow it.

Looking for an alternative workaround or my mistake.

The setup

I did not use the actual code, and that should not matter IMO. Seems like a conceptional problem to me.

The class TObjectWithInterface implements the interface ISomeInterface and extends the class TCustomInterfacedObject, which simply works around the reference counting of IInterface as given in the documentation.

TObjectWithInterface = class(TCustomInterfacedObject, ISomeInterface)

If have a procedure which takes a list of objects implementing that interface:

procedure SomeFunction(List: TList<ISomeInterface>)

The issue

Inside of a function of TObjectWithInterface, I try to call that function, using a list of objects of TObjectWithInterface:

procedure TObjectWithInterface.DoTheStuff(ListOfObjects: TList<TObjectWithInterface>)
begin
  // ...
  SomeFunction(ListOfObjects); // <-- Compiler error: Incompatible types
  // ...  
end;

The compiler tells me the following:

E2010: Incompatible types: 'System.Generics.Collections.TList' and 'System.Generics.Collections.TList'

The dumb workaround

I really dislike my current workaround, which consists of creating a new list and type casting each TObjectWithInterface to ISomeInterface:

procedure TObjectWithInterface.DoTheStuff(ListOfObjects: TList<TObjectWithInterface>)
var
  ListOfInterfaceObjects: TList<ISomeInterface>;
begin
  // ...
  ListOfInterfaceObjects := TList<ISomeInterface>.Create;
  for var Object in ListOfObjects do
    ListOfInterfaceObjects.Add(Objects as ISomeInterface);
  SomeFunction(ListOfInterfaceObjects)
  // ...  
end;

This seems very hacky to me. I may have done something stupid, or do not understand something correctly, as this is the first time, that I am trying to use Interfaces in Delphi. Please don't be mad.

Either way, I hope someone can point out my mistake or, if this is a language limitation, has an alternative workaround.

CodePudding user response：

Your "workaround" to copy the list of objects into a separate list of interfaces is actually the correct and proper solution. You can't use a TList<X> where a TList<Y> is expected, they are different and unrelated types. Just because you are disabling reference counting on the interfaces doesn't change the memory layout of the objects in relation to their interfaces, so you still have to pass around proper memory pointers, which means performing necessary conversions from one to the other.