Pure interfaces in Delphi

In a comment on the recent interface-list blog post Huseyn asks:

“In Delphi we expect all interfaces be descendants of IUnknown [or IInterface - HV], but in [the] C world there are many even more basic interfaces which are not inherited from IUnknown. I came across one of them in a DLL which I need to use. But I couldn't do it using Delphi.”

It is true that a Delphi interface declaration always implicitly inherits from IUnknown or IInterface (to distinguish between COM interfaces and Delphi language interfaces). This means that all interfaces have the three methods QueryInterface, _AddRef and _Release. This makes it hard (or impossible) to implement a pure interface from a non-COM DLL using a Delphi interface declaration.

Back in the dark ages of Delphi 2, there where no explicit interfaces and COM support was built on the fact that the VMT table layout matched COM’s binary contract, and “interfaces” were declared using pure abstract base classes. This is how interfaces are still declared in C++, for instance. The class that wanted to implement such an “interface” would simply inherit directly from the pure abstract class, overriding and implementing the all the abstract methods. This was a very restrictive way of implementing interfaces; due to the fact the Delphi does not support multiple inheritance of classes - if you wanted to support multiple interfaces, you had to write one class per interface and manually write the QueryInterface method to return the correct interface/object reference. C++ does not have that restriction and is probably why it doesn’t have a separate language construct for interfaces, in contrast to languages such as Java, Delphi and C# that all have a single-inheritance model.

This little history lesson should give us a clue of how we can avoid the IUnknown methods of normal interfaces – we can simply declare and implement a pure abstract class instead.

For instance:

program TestPureInterface;
{$APPTYPE CONSOLE}
type
  TMyPureInterface = class
    procedure FirstMethod stdcall; virtual; abstract; 
    procedure SecondMethod stdcall; virtual; abstract; 
  end;
 
  TMyImplementation  = class(TMyPureInterface)
  public
    procedure FirstMethod; override; 
    procedure SecondMethod; override;
  end;
   
procedure TMyImplementation.FirstMethod;
begin
  Writeln('TMyImplementation.FirstMethod');
end;
 
procedure TMyImplementation.SecondMethod;
begin
  Writeln('TMyImplementation.SecondMethod');
end;
 
procedure TestClient(PureInterface: TMyPureInterface);
begin
  PureInterface.FirstMethod;
  PureInterface.SecondMethod;
end;  
 
var
  MyImplementation: TMyImplementation;
begin
  MyImplementation := TMyImplementation.Create;
  TestClient(MyImplementation);
  readln;
end.

This little sample code first declares a pure abstract class with to virtual abstract methods. This is a declaration of the COM-less interface the C-based DLL in question expects to talk to. Note that I assume the calling convention is stdcall and the specific ordering and semicolon use the compiler insists upon (which disagrees with Error Insight in Delphi 2006):

    procedure FirstMethod stdcall; virtual; abstract;

Then we implement the “interface” by writing a class that inherits from the abstract base class, implementing the required methods. Notice that the compiler does not require that we repeat the calling convention for the overrides:

    procedure FirstMethod; override;

Finally I’ve written some test code that exercises calling the implemented methods through the “interface” reference, typed as the abstract base class. This corresponds to the C code in the DLL we’re providing the interface implementation for.