Implementing Interfaces by Delegation in Delphi!

Implementing Interfaces by Delegation

Is it possible at all?😮

The implements directive allows you to delegate the implementation of an interface to a property in the implementing class. For example:

  property MyInterface: IMyInterface read FMyInterface implements IMyInterface;

Declares a property called MyInterface that implements the interface IMyInterface.

The implements directive must be the last specifier in the property declaration and can list more than one interface, separated by commas. The delegate property:
Must be of a class or interface type.
Cannot be an array property or have an index specifier.
Must have a read specifier. If the property uses a read method, that method must use the default register calling convention and cannot be dynamic (though it can be virtual) or specify the message directive.
The class you use to implement the delegated interface should derive from System.TAggregatedObject.
Delegating to an Interface-Type Property
If the delegate property is of an interface type, that interface, or an interface from which it derives, must occur in the ancestor list of the class where the property is declared. The delegate property must return an object whose class completely implements the interface specified by the implements directive, and which does so without method resolution clauses. For example:

type
  IMyInterface = interface
    procedure P1;
    procedure P2;
  end;
  TMyClass = class(TObject, IMyInterface)
    FMyInterface: IMyInterface;
    property MyInterface: IMyInterface read FMyInterface implements IMyInterface;
  end;
var
  MyClass: TMyClass;
  MyInterface: IMyInterface;
begin
  MyClass := TMyClass.Create;
  MyClass.FMyInterface := ...// some object whose class implements IMyInterface
  MyInterface := MyClass;
  MyInterface.P1;
end;

Delegating to a Class-Type Property

If the delegate property is of a class type, that class and its ancestors are searched for methods implementing the specified interface before the enclosing class and its ancestors are searched. Thus it is possible to implement some methods in the class specified by the property, and others in the class where the property is declared. Method resolution clauses can be used in the usual way to resolve ambiguities or specify a particular method. An interface cannot be implemented by more than one class-type property. For example:

type
  IMyInterface = interface
    procedure P1;
    procedure P2;
  end;
  TMyImplClass = class
    procedure P1;
    procedure P2;
  end;
  TExternalClass = class(TInterfacedObject, IMyInterface)
  private
    FMyImplClass: TMyImplClass;
  public  
    procedure IMyInterface.P1 = MyP1AlternativeProcedure;
    procedure MyP1AlternativeProcedure;
    
    property MyImplClass: TMyImplClass read FMyImplClass implements IMyInterface;
  end;
  
  procedure TMyImplClass.P1;
  begin
    Writeln('P1 called!');
  end;
  
  procedure TMyImplClass.P2;
  begin
    Writeln('P2 called!');
  end;
  
  procedure TExternalClass.MyP1AlternativeProcedure;
  begin
    Writeln('MyP1AlternativeProcedure called!');
  end;

var
  LvMyExternalClass: TMyClass;
  LvMyInterface: IMyInterface;
begin
  LvMyExternalClass := TExternalClass.Create;
  LvMyExternalClass.FMyImplClass := TMyImplClass.Create;
  
  LvMyInterface := LvMyExternalClass;
  LvMyInterface.P1;  // calls TMyClass.MyP1AlternativeProcedure;
  LvMyInterface.P2;  // calls TImplClass.P2;
  Readln;
end;

You can remove the following lines from TExternalClass and it's still implementing the interface correctly and compilable!

    procedure IMyInterface.P1 = MyP1AlternativeProcedure;
    procedure MyP1AlternativeProcedure; // and its implementation!

Here is another console-type application sample to make it more clear:

program InterfaceDelegationDemo;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
  // Interface definition
  IFirstInterface = interface
    procedure FirstMethod;
  end;

  ISecondInterface = interface
    procedure SecondMethod;
  end;

  // Implementation of the first interface
  TFirstInterfaceImplementation = class(TInterfacedObject, IFirstInterface)
    procedure FirstMethod;
  end;

  // Implementation of the second interface using delegation
  TSecondInterfaceImplementation = class(TInterfacedObject, ISecondInterface)
  private
    FFirstInterfaceImpl: IFirstInterface;
  public
    constructor Create(AFirstInterfaceImpl: IFirstInterface);
    procedure SecondMethod;
  end;

{ TFirstInterfaceImplementation }

procedure TFirstInterfaceImplementation.FirstMethod;
begin
  Writeln('FirstMethod called');
end;

{ TSecondInterfaceImplementation }

constructor TSecondInterfaceImplementation.Create(AFirstInterfaceImpl: IFirstInterface);
begin
  FFirstInterfaceImpl := AFirstInterfaceImpl;
end;

procedure TSecondInterfaceImplementation.SecondMethod;
begin
  Writeln('SecondMethod called');
  FFirstInterfaceImpl.FirstMethod; // Delegating the method call to the first interface implementation
end;

var
  FirstInterfaceImpl: IFirstInterface;
  SecondInterfaceImpl: ISecondInterface;
begin
  FirstInterfaceImpl := TFirstInterfaceImplementation.Create;
  SecondInterfaceImpl := TSecondInterfaceImplementation.Create(FirstInterfaceImpl);

  SecondInterfaceImpl.SecondMethod;
  Readln;
end.

In this code, we have two interfaces, IFirstInterface and ISecondInterface. The TFirstInterfaceImplementation class implements the first interface, and the TSecondInterfaceImplementation class implements the second interface using delegation.

The TSecondInterfaceImplementation class takes an instance of IFirstInterface as a constructor parameter, which represents the first interface implementation. It stores this instance in the FFirstInterfaceImpl field.

When the SecondMethod of TSecondInterfaceImplementation is called, it first prints a message indicating that the method has been called. Then, it delegates the method call to the FirstMethod of the first interface implementation by calling FFirstInterfaceImpl.FirstMethod.

By using this delegation approach, you can separate the implementation of each interface and reuse existing implementations by passing them as parameters to other interface implementations.