unit Unit1;

interface

uses
  System.SyncObjs,
  System.SysUtils;

type
  TCustomerId = type Integer;

  TCustomerDTO = class
  private
    FId  : TCustomerId;
    FName: string;
  public
    property Id  : TCustomerId read FId write FId;
    property name: string read FName write FName;
  public
    function ToString( ): string; override;
  end;

  ICustomerRepository = interface
    [ '{9B0E352B-F236-47F7-A817-A3CCB83A5DA8}' ]
    function Get( const Id: TCustomerId ): TCustomerDTO;
    function Post( const Customer: TCustomerDTO ): TCustomerDTO;
    procedure Delete( const Id: TCustomerId );
  end;

  TCustomerModel = class
  private
    FRepository: ICustomerRepository;
    FData      : TCustomerDTO;
    function GetId: TCustomerId;
    procedure SetId( const Value: TCustomerId );
    function GetName: string;
    procedure SetName( const Value: string );
  public
    property Id  : TCustomerId read GetId write SetId;
    property name: string read GetName write SetName;
  public
    // DI via Container
    constructor Create( ); overload;
    // DI via constructor
    constructor Create( const Repository: ICustomerRepository ); overload;
    destructor Destroy; override;

    procedure Delete( );
    procedure Fetch( );
    procedure Save( );

    function ToString( ): string; override;
  end;

  // Very Simple DI Container

  Repositories = class
  private
    class var FCustomerRepository: TFunc<ICustomerRepository>;
  public
    class property CustomerRepository: TFunc<ICustomerRepository> read FCustomerRepository write FCustomerRepository;
  end;

implementation

{ TCustomerModel }

constructor TCustomerModel.Create( const Repository: ICustomerRepository );
begin
  inherited Create( );

  FRepository := Repository;
  FData       := TCustomerDTO.Create;
end;

constructor TCustomerModel.Create;
begin
  // Get the Repo from Container
  Create( Repositories.CustomerRepository( ) );
end;

procedure TCustomerModel.Delete;
begin
  FRepository.Delete( Id );
end;

destructor TCustomerModel.Destroy;
begin
  FData.Free;
  inherited;
end;

procedure TCustomerModel.Fetch;
var
  lData: TCustomerDTO;
begin
  lData := FRepository.Get( Id );
  try
    lData := TInterlocked.Exchange( FData, lData );
  finally
    lData.Free;
  end;
end;

function TCustomerModel.GetId: TCustomerId;
begin
  Result := FData.Id;
end;

function TCustomerModel.GetName: string;
begin
  Result := FData.Name;
end;

procedure TCustomerModel.Save;
var
  lData: TCustomerDTO;
begin
  lData := FRepository.Post( FData );
  try
    lData := TInterlocked.Exchange( FData, lData );
  finally
    lData.Free;
  end;
end;

procedure TCustomerModel.SetId( const Value: TCustomerId );
begin
  FData.Id := Value;
end;

procedure TCustomerModel.SetName( const Value: string );
begin
  FData.Name := Value;
end;

function TCustomerModel.ToString: string;
begin
  Result := FData.ToString( );
end;

{ TCustomerDTO }

function TCustomerDTO.ToString: string;
begin
  Result := Format( '{"id":%d, "name":"%s"}', [ Id, name ] );
end;

end.

{**************************}

unit Unit2;

interface

uses
  Unit1, System.SysUtils;

type
  TFakeCustomerRepository = class( TInterfacedObject, ICustomerRepository )
  private { ICustomerRepository }
    procedure Delete( const Id: TCustomerId );
    function Get( const Id: TCustomerId ): TCustomerDTO;
    function Post( const Customer: TCustomerDTO ): TCustomerDTO;
  end;

implementation

{ TFakeCustomerRepository }

procedure TFakeCustomerRepository.Delete( const Id: TCustomerId );
begin
  WriteLn( Format( '>>> Delete(%d)', [ Id ] ) );
end;

function TFakeCustomerRepository.Get( const Id: TCustomerId ): TCustomerDTO;
begin
  WriteLn( Format( '>>> Get(%d)', [ Id ] ) );
  // return a faked customer
  Result      := TCustomerDTO.Create( );
  Result.Id   := Id;
  Result.name := 'SomeCustomer';
end;

function TFakeCustomerRepository.Post( const Customer: TCustomerDTO ): TCustomerDTO;
begin
  WriteLn( Format( '>>> Post(%s)', [ Customer.ToString() ] ) );
  // Copy then Customer
  Result      := TCustomerDTO.Create( );
  Result.Id   := Customer.Id;
  Result.name := Customer.name;
end;

end.

{**************************}

program Project3;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils,
  Unit1 in 'Unit1.pas',
  Unit2 in 'Unit2.pas';

procedure Main( );
var
  lCustomer: TCustomerModel;
begin
  lCustomer := TCustomerModel.Create( );
  try

    lCustomer.Id := 42;
    lCustomer.Fetch( );

    WriteLn( lCustomer.ToString( ) );

    lCustomer.Name := 'FooBar';

    WriteLn( lCustomer.ToString( ) );

    lCustomer.Save( );

  finally
    lCustomer.Free;
  end;
end;

begin
  try
    // Setup the DI Container
    Repositories.CustomerRepository :=
      function: ICustomerRepository
      begin
        Result := TFakeCustomerRepository.Create( );
      end;

    Main( );

  except
    on E: Exception do
      WriteLn( E.ClassName, ': ', E.Message );
  end;
  ReadLn;

end.