Probleme mit der Lazy initialization by Spring4d

[brieker]

Moin alle zusammen.

Ich beschäftige mich nun seit 2 Wochen mit Spring4d.

Ich habe versucht das hier gezeigte Lazy Implementation Schema in meinem Code einzubauen um eine Reihe von Objekten zur Laufzeit zu generieren und in einer Liste zu hinterlegen.

Allerdings habe ich noch nicht heraus gefunden wie ich die Factory hinter getService() überhaupt erreichen soll ohne wieder die DI über den haufen zu werfen.

Hat einer von euch Erfahrung mit Spring4d und Lazy und kann mir helfen meine Wissenslücken zu schliessen.

Hier mal eine gekürzte Version des Objekts das zur Laufzeit inizialisiert werden soll.

Code:

unit uColor;

interface

uses System.Types,
     Interfaces,
     Spring,
     Spring.Services,
     SysUtils;

procedure RegisterColorService(aServiceName: string);

implementation

uses Spring.Container;

type
  TColor = class(TInterfacedObject, IColor)
  private
    fService: Lazy<IColor>;
  protected
  public
    constructor Create(const service: Lazy<IColor>);

    function GetService: IColor;
    property Service: IColor read GetService;
  End;

  Constructor TColor.Create(const service: Lazy<IColor>);
  begin
    inherited Create;
    fservice := service;
  End;

  function TColor.GetService: IColor;
  begin
    Result := fService;
  end;

  procedure RegisterColorService();
  begin
    GlobalContainer.RegisterType<TColor>.Implements<IColor>('default').AsTransient.AsDefault;
    GlobalContainer.Build;

    Assert(GlobalContainer.Resolve<IColor>.Service is TColor);
  end;

End.

Währe für jede Hilfe dankbar.

CU Benjamin Rieker

[CarlAshnikov]

Falls ich das richtig verstanden habe, ist dein Problem, dass du TColor in sich selbst injizieren willst.

Im Beispiel wird ein IExampleService in den THomeController injiziert und dieser dann aufgelöst. Der Container übergibt dann automatisch ein Lazy<IExampleService> in den constructor von THomeController wenn einer gebaut wird.

Angewendet auf dein Beispiel (nicht getestet):

Delphi-Quellcode:

type
  IColor = interface;
  
  TColor = class(TInterfacedObject, IColor)

  End;

  TExample = class
  private
    fService: Lazy<IColor>;
  protected
  public
    constructor Create(const service: Lazy<IColor>);

    function GetService: IColor;
    property Service: IColor read GetService;
  End;

  Constructor TExample.Create(const service: Lazy<IColor>);
  begin
    inherited Create;
    fservice := service;
  End;

  function TExample.GetService: IColor;
  begin
    Result := fService;
  end;

  procedure RegisterColorService();
  begin
    GlobalContainer.RegisterType<TColor>.Implements<IColor>('default').AsTransient.AsDefault;
    GlobalContainer.RegisterType<TExample>;
    GlobalContainer.Build;

    Assert(GlobalContainer.Resolve<TExample>.Service is TColor);
  end;

[brieker]

Moin CarlAshnikov,

nein so ist es leider nicht ganz.

Ich habe eine Klasse TColor mit dem dazu gehörigen Interface IColor und eine weitere Klasse TColorPalette mit dem Interface IColorPalette sowohl Color als auch ColorPalette sind im DI-Container Regestriert.

In der TColorPalette gibt es eines Procedure AddColor(color:IColor) die eine Color Objekt an eine Liste anhängt.
Beim Aufruf von AddColor muss ich ja eine neue Instanz von TFarbe aus dem DI-Container hollen und übergeben.
Mit ServiceLocator.GetService<IColor> wär es ja ein leichtes aber das ist ja ein NO-GO.
Darum habe ich versucht diese Lazy Methode zu implementieren, was im endeffekt eine Factory darstellt.
Aber wenn ich versuche von der Factory eine neue Instanz zu bekommen muss ich wieder ungewollte Dependencies machen sonnst kann Delphi damit nix anfangen.
Dann kann ich auch gleich wieder ServiceLocator benutzen.

Es ist halt nervig das man nicht im Vorraus weis ob die Palette 8 oder 32000 Faren haben soll sonnst könnte ich das mit Constructor-Injection erschlagen.

Ich habe auch schon darüber nachgedacht mit Constructor-Injection eine Dummy-Color in meine Palette zu schmuggeln und bei AddColor einen Clon vom Dummy in die Liste zu packen aber dass ist auch nicht ganz koscher denke ich.

MfG Benjamin

[CarlAshnikov]

Ich denke in diesem Fall sollte sich TColorPalette eine FactoryMethode (TFunc<IColor>) vom DI-Container injizieren lassen. Diese kannst du dann bei jedem AddColor aufrufen.

Ich denke Lazy stellt genau eine Instanz bereit. Da du aber mehrere brauchst um deine Liste zu füllen, benötigst du die Methode um sie mehrfach aufzurufen.

Delphi-Quellcode:

type
  IColor = interface;
  
  TColor = class(TInterfacedObject, IColor)

  End;

  TColorPalette = class
  private
    fFactory: TFunc<IColor>;
    fColors: IList<IColor>;
  protected
  public
    constructor Create(const AFactory: TFunc<IColor>);
    procedure AddColor;
  End;

  Constructor TColorPalette.Create(const AFactory: Lazy<IColor>);
  begin
    inherited Create;
    fFactory := AFactory;
    fColors := TCollections.CreateList<IColor>();
  End; 

  procedure TColorPalette.AddColor;
  begin
    fColors.Add(fFactory());
  end;

  procedure RegisterColorService();
  begin
    GlobalContainer.RegisterType<TColor>.Implements<IColor>('default').AsTransient.AsDefault;
    GlobalContainer.RegisterType<TColorPalette>;
    GlobalContainer.Build;    
  end;