E2010 - Incompatible Types-Fehler in generischer Factory

[TiGü]

Hallo zusammen,

in einen Anflug von Genie und/oder Wahnsinn wollte ich mir eine "sehr" generische Factory bauen:

Delphi-Quellcode:

unit Common.Factory;

interface

uses
  System.SysUtils,
  System.Generics.Collections;

type
  TCommonFactory<Kind, Output, TFactoryFunction, ConstructParameter> = class abstract
  public type
    TFactoryFunction = reference to function(const AConstructParameter : ConstructParameter) : Output;
  private
    class var
      FFactoryDictionary : System.Generics.Collections.TDictionary<Kind, TFactoryFunction>;
    class constructor Create;
    class destructor Destroy;
  public
    class procedure Register(const AKind : Kind; const AConstructFunction : TFactoryFunction); 
    class function Get(const AKind : Kind; const AConstructParameter : ConstructParameter) : Output; 
  end;

implementation

class constructor TCommonFactory<Kind, Output, TFactoryFunction, ConstructParameter>.Create;
begin
  FFactoryDictionary := System.Generics.Collections.TDictionary<Kind, TFactoryFunction>.Create;
end;

class destructor TCommonFactory<Kind, Output, TFactoryFunction, ConstructParameter>.Destroy;
begin
  FreeAndNil(FFactoryDictionary);
end;

class function TCommonFactory<Kind, Output, TFactoryFunction, ConstructParameter>.Get(const AKind : Kind; const AConstructParameter : ConstructParameter) : Output;
var
  LConstructFunction : TFactoryFunction;
begin
  Result := default (Output);
  if FFactoryDictionary.TryGetValue(AKind, LConstructFunction) then
  begin
    Result := LConstructFunction(AConstructParameter);
  end;
end;

class procedure TCommonFactory<Kind, Output, TFactoryFunction, ConstructParameter>.Register(const AKind : Kind; const AConstructFunction : TFactoryFunction);
begin
  FFactoryDictionary.Add(AKind, AConstructFunction); //<--- Fehler
end;

end.

Leider sagt mir mein XE7, dass beim Add ein E2010 vorliegt:

Code:

[dcc32 Error] Common.Factory.pas(48): E2010 Incompatible types: 'Common.Factory.TCommonFactory<Common.Factory.TCommonFactory<Kind,Output,TFactoryFunction,ConstructParameter>.Kind,
Common.Factory.TCommonFactory<Kind,Output,TFactoryFunction,ConstructParameter>.Output,
Common.Factory.TCommonFactory<Kind,Output,TFactoryFunction,ConstructParameter>.TFactoryFunction,
Common.Factory.TCommonFactory<Kind,Output,TFactoryFunction,ConstructParameter>.ConstructParameter>.TFactoryFunction' and 'TFactoryFunction'

Die Fehlermeldung ist ja schon so undurchschaubar lang.
Ich weiß, dass die Generics immer noch mit Bugs zu kämpfen haben und ich werde mein Problem wohl anders lösen müssen.

Hat jemand eine Idee, woran das liegen könnte bzw. wie ich elegant mein Problem löse?

Letztendlich geht es darum, das man ein Enum-Wert übergibt (

Delphi-Quellcode:

Kind

) und man dafür ein Interface zurück bekommt (

Delphi-Quellcode:

Output

).
Die Instanzen sollen über (anonyme) Factory-Funktionen (

Delphi-Quellcode:

TFactoryFunction

) erstellt werden, die ein Parameter benötigen (

Delphi-Quellcode:

ConstructParameter

).

[himitsu]

Zitat:

type
_ TCommonFactory<Kind, Output, TFactoryFunction, ConstructParameter> = class abstract
_ public type
_ _ TFactoryFunction = reference to function(const AConstructParameter : ConstructParameter) : Output;
_ private

Fällt dir was auf?

So geht es

Delphi-Quellcode:

TCommonFactory<Kind, Output, FactoryFunction, ConstructParameter> = class abstract

, auch wenn FactoryFunction scheinbar nirgendwo benutzt wird.

[TiGü]

Uuuh, danke! :shock:

Manchmal sieht man den Wald vor lauter Bäumen nicht! :thumb:

[TiGü]

Ach, ich stoße ständig gegen weitere Wände!
Ich lasse den generischen Ansatz sein und mache es auf die klassische Tour.
Dann versteht man den Quelltext auch in zwei Wochen noch und die Kollegen auch! :D

Also eher sowas, wobei

Delphi-Quellcode:

TMCS2Outputs

ein Enum ist und

Delphi-Quellcode:

TActuatorClass

ein

Delphi-Quellcode:

class of

.

Delphi-Quellcode:

type
  TActuatorFactory = class abstract
  strict private
    class var
      FActuatorDictionary : TDictionary<TMCS2Outputs, TActuatorClass>;
    class constructor Create;
    class destructor Destroy;
  public
    class procedure RegisterActuator(const OutputKind : TMCS2Outputs; const AClass : TActuatorClass);
    class function GetActuator(const OutputKind : TMCS2Outputs; const CardID : TCardID) : IActuator;
  end;

implementation

class constructor TActuatorFactory.Create;
begin
  FActuatorDictionary := TDictionary<TMCS2Outputs, TActuatorClass>.Create;
end;

class destructor TActuatorFactory.Destroy;
begin
  FreeAndNil(FActuatorDictionary);
  inherited;
end;

class function TActuatorFactory.GetActuator(const OutputKind : TMCS2Outputs; const CardID : TCardID) : IActuator;
var
  LClass : TActuatorClass;
begin
  Result := nil;
  if FActuatorDictionary.TryGetValue(OutputKind, LClass) then
  begin
    Result := LClass.Create(CardID);
  end;
end;

class procedure TActuatorFactory.RegisterActuator(const OutputKind : TMCS2Outputs; const AClass : TActuatorClass);
begin
  FActuatorDictionary.Add(OutputKind, AClass);
end;