Question

I am writing a simple dependency injection / inversion of control system based on a TDictionary holding abstract class references with their respective implementor classes.

My goals are:

• Avoid direct instantiation by type (obviously).
• Inclusion of a class’ unit in the dpr should be enough to have it registered and be available for selection and instantiation through the di/ioc system.
• Declare concrete implementing classes in implementation section only.
• Use class constructors instead of initialization sections.

Btw, I am aware that using class constructors to take advantage of smart linking and wanting the inclusion of a unit to be enough to make a class available are defeating each other. I want to use class constructors instead of initialization sections for other reasons as well. And I would like to keep all class initialization/registration code together instead of having to split it between the class constructor and initialization section.

Problem

I want the registration of the class into the factory to be in the class constructor. Unfortunately, the compiler doesn’t think the class is “touched” by just using its type in its own class constructor.

When I put the registration function in the initialization section, then the compiler does think the class is touched and calls the class constructor. But that defeats the object of my exercise of keeping all class initialization code in the class constructor.

Two questions

• Should the compiler consider the use of the class in its own class constructor “touching the class” or is that too much to expect the compiler to do?
• Does anybody have any clever ideas on how I can still achieve my goals without using the initialization section?

Example

The abstract classes used in the application:

TSite = class abstract (TObject)
  function GetURL: string; virtual; abstract;
  property URL: string read GetURL;
end;

TSites = class (TList<TSite>);

TThisApplication = class abstract (TObject)
  function Sites: TSites; virtual; abstract;
end;

The concrete implementing class (declared in the implementation section!) for TThisApplication

  TThisApplicationConcrete = class(TThisApplication)
  class constructor ClassCreate;
  strict private
    FSites: TSites;
    function Sites: TSites; override;
  end;

class constructor TThisApplicationConcrete.ClassCreate;
begin
  RegisterImplementorClass(TThisApplication, TThisApplicationConcrete);
end;

function TThisApplicationConcrete.Sites: TSites;
var
  SiteList: TSites;
begin
  if not Assigned(FSites) then begin
    SiteList := TSites.Create;  // Change to use factory
    //RetrieveSites(SiteList);
    FSites := SiteList;
  end;

  Result := FSites;
end;

The function to get an instance of TThisApplication:

function ThisApplication: TThisApplication;
var
  ImplementorClass: TClass;
begin
  ImplementorClass := GetImplementorClass(TThisApplication);
  if Assigned(ImplementorClass) then begin
    Result := ImplementorClass.Create as TThisApplication;
  end else begin
    Result := nil;
  end;
end;

This is currently coded in a separate function, but it w/could be moved to the factory.

Full example code

If anybody would like to experiment, I have the full code of my test projects available at : http://www.bjsoftware.com/delphistuff/stackoverdlow/classconstructors.zip

Zip contents:

• 4 projects all using the same source files, differing only in conditional defines (that’s why the dproj’s are also included)
• 4 source files
• groupproj and its dsk with all 4 projects
• RunTestApps.cmd to run all 4 projects
• Results.txt with the output of my run of the RunTestApps.cmd
• WriteUp.txt with the text of this question

Please bear in mind that at all times you need to do a “Build All Projecs” because all dcu’s and exe’s are going to the source dir and otherwise you are going to face a lot of errors and/or confusion because the exe isn’t doing what its name indicates.

Answer 1

This is as expected. As Uwe pointed out, a self-referential class constructor isn’t enough to trigger inclusion. Placing the reference in the initialization section will do the trick since that is outside the class itself. Trying to self-reference a class for inclusion is akin to trying pull yourself out of a deep hole by pulling on your own suspenders.