SingletonService

SingletonService.pas

unit Service;

type
  IService = interface
    procedure DoServiceThing;
  end;
  
  TFactory<T> = reference to function: T;
  
  unit ServiceImpl;
  
 uses
   Service;
    
 type
   TServiceImpl = class(TInterfacedObject, IService)
   strict private
     procedure DoServiceThing;
   end;
   
unit Globals;

uses
  Service;

type
  TGlobalService = record
  strict private
    class var FService: IService;
    class var FServiceFactory: TFactory<IService>;
    
    class function GetService: IService; static; inline;
    class function GetServiceFactory: TFactory<IService>; static; inline;
    class procedure SetServiceFactory(const Value: TFactory<IService>); static; inline;
  public
    class property Service: IService read GetService;
    class property ServiceFactory: TFactory<IService> read GetServiceFactory write SetServiceFactory;
  end;
  
 implementation
 
 uses
   System.SysUtils;
 
class function TGlobalService.GetService: IService;
begin
  if not Assigned(FService) then
  begin
    if not Assigned(FServiceFactory) then
      raise EArgumentNilException.Create('ServiceFactory');

    FService := FServiceFactory();
  end;

  Result := FService;
end;

class function TGlobalService.GetServiceFactory: TFactory<IService>;
begin
  Result := FServiceFactory;
end;

class procedure TGlobalService.SetServiceFactory(const Value: TFactory<IService>);
begin
  FServiceFactory := Value;
end

// consumer code

begin
  // initialization
  TGlobalService.ServiceFactory := function: IService
                                   begin
                                    Result := TServiceImpl.Create;
                                   end;
                                  
  // somewhere latter...
  TGlobalService.Service.DoServiceThing;
end.