Abgeleitete Klassen auf einzelne Units verteilen

[BastiFantasti]

Hallo zusammen,

ich bin gerade am überlegen, wie ich mehrere von einer Elternklasse abgeleitete Unterklassen in einzelne Units auslagern kann -
und vor allem welche Units dann nachher für die Verwendung implementiert werden müssen.

Meine angedachte Struktur sieht so aus:

Code:

class TParentDevice

class TDeviceType1(TParentDevice)

class TDeviceType2(TParentDevice)

class TDeviceType3(TParentDevice)

Aufgrund des Umfangs der jeweiligen Implementierungen möchte ich die abgeleiteten Klassen nun in separate Units stecken.

z.B.

Code:

uParentDevice -> TParentDevice
uDevType1 -> TDeviceType1
uDevType2 -> TDeviceType2
uDevType3 -> TDeviceType3

In den jeweiligen uDevType* Units muss die uParentDevice unit in die "uses" Liste aufgenommen werden
um die TParentDevice Klasse ableiten zu können.

Wie aber werden nun die abgeleiteten Klassen richtig in einer Anwendung implementiert bzw. importiert?
Ich könnte natürlich in einer Case Struktur oder über Defines die jeweiligen Konstruktoren in jeder Unit in der die Klassen benötigt werden implementieren.
Dies hätte aber zur Folge, dass ich alle neu hinzukommenden Implementierungen immer in den uses aller Units nachführen müsste.
Zudem wird der Code dadurch nicht leserlicher wenn immer noch mehr defines oder cases hinzu kommen.

Ich denke, ich werde eine weitere Unit mit einer weiteren Klasse für die Implementierung in die jeweilige Anwendung anlegen - so zu sagen als Wrapper.
So käme zu den 4 o.g. Units noch eine weitere dazu, die die direkte Schnittstelle zur Anwendung darstellt und dort in die uses aufgenommen wird.

z.B. ein TDeviceHandler der im Constructor den jeweiligen DeviceType als TypeDef übergeben bekommt und intern die jeweilige Implementierung instanziert.
Der Vorteil wäre, dass neu hinzukommende abgeleitete Klassen nur in dem TDeviceHandler bekannt gegeben und implementiert werden müssen.


evtl. so:

Code:

var
   dh : TDeviceHandler;

begin
  dh := TDeviceHandler.create(dtDeviceType1);
  dh.free;
end;

und intern dann in dem TDeviceHandler.constructor

Code:

var
  MyDevice : TParentDevice;  
begin
  case dtDeviceType of:
    dtDeviceType1:
     begin
       myDevice := TDeviceType1.create;
     end;
    dtDeviceType2:
     begin
       myDevice := TDeviceType2.create;
     end;
end;

Ist der "Wrapper" Ansatz der richtige oder gibt es noch eine bessere Möglichkeit dieses Szenario zu implementieren?

Danke schon mal für eure Ideen und Anregungen

Viele Grüße
Bastian