Custom Constructor /DI bei factory-basierter Objekterstellung

[Sequitar]

hallo, zusammen.
ich arbeite zzt relativ viel über DLL grenzen und hab das ganze auch schon gut mit interfaces und einer zentralen factory zur Registrierung und Erstellung neuer Typen hinbekommen.

Jetzt würde ich neben der bisherigen Vorgehensweise (Interfaces, Value access per properties )auch gerne objekte bereits bei der Erstellung mit startparametern ausstatten (incl. und besonders auch i.V.m Dependency injection).

Die Frage die sich mir stellt, ist wie ich hierzu eigens definierte / verdeckende constructoren einführe, die ich in einer Factory nutzen kann, was ja bei normaler Vererbung möglich ist (also z.b.

Delphi-Quellcode:

// in einer DLL registrierter Typ
Type
  Ix = Interface
    [GUID]
    Function Getint: Integer;
    Procedure Setint(Anint: Integer);
    Property Anint: Integer Read Getint Write Setint;
  End;

  Tx = Class(Tinterfacedobject, Ix)
  Private
    Fint: Integer;
    Function Getint: Integer;
    Procedure Setint(Anint: Integer);
  Public
    Constructor Create(Anint: Integer);
  End;

  { ... }
Constructor Tx.Create(Anint: Integer);
Begin
  Fint := Anint;
End;

Function Tx.Getint: Integer;
Begin
  Result := Fint;
End;

Procedure Tx.Setint(Anint: Integer);
Begin
  Fint := Anint;
End;

Initialization

// globale factory, oder davon abgeleitet: Txfactory=Tfactory<TX>;
Txfactory.Register(Tx); // läuft soweit

Finalization

Txfactory.Unregister(Tx);

in anderer unit /anderem DLL modul soll dann sowas aufgerufen werden

Delphi-Quellcode:

Procedure New;
Var
  Xclass: Txclass;
  // txclass ist der hauptanwendung und anderen modulen ja an sich unbekannt, daher später vlt
  // Var xclass:tinterfacedclass;
  X,y: Tinterfacedobject;
Begin
  Xclass := Txclass { Tinterfacedclass } (Txfactory.Getclass('tx'));//txclass i.A. unbekannt, da in externer DLL definiert und registriert. steht jetz nur mal so da zur verdeutlichung.
  // custom constructor, future dependency injection planned
  X := Xclass.Create(5);
//oder auch möglich
y:=txfactory.new('tx');
  // << << Wie Kann Ich in beiden fällen Auf Den Custom Constructor Von Tx Zugreifen ? TX und TXclass sind normal ausserhalb der DDL unbekannt
  Assert((X as ix).Anint = 5);
  X.Free;
  y.free;
End;

bisher mach ich das dann so, kann aber keine dependencies mitgeben //fehlende konstructoren:

Delphi-Quellcode:

procedure new;
var x,y:ix;
xclass:tinterfacedclass;
 Xclass := Tinterfacedclass{Txclass}(Txfactory.Getclass('tx'));
        // custom constructor, future dependency injection planned
 X := Xclass.create as ix;//<<<< wie kann ich hier auf den custom constructor von tx zugreifen?
x.anint:=5;
 Assert(X.Anint = 5);
x:=nil;
//oder so:
y:=txfactory.new('tx')as ix;
y.anint:=42;
y:=nil;
{...}

ich könnte mir auch vorstellen, die jeweiligen constructoren direkt mit in der factory zu registrieren (reference to constructor gibts aber leider nicht, theoretisch würde das mein problem ja lösen, aber ich weiss einfach nicht wie das zu realisieren ist)
also sowas in der art:
txfactory.register(tx,tx.create({custom parameters}));