Unit "dynamisch" einbinden

[ernschd]

Folgendes Problem:
Ich habe eine Unit „Les“:

Delphi-Quellcode:

Unit Les;
…
Procedure LeseDatei(Name: String);
begin
   AssignFile(Name…
end;

Dann gibt es die Unit „LesSQL“:

Delphi-Quellcode:

Unit LesSQL;
…
Procedure LeseDatei(Name: String);
begin
   Sql := „SELECT * FROM `Name`…
end;

Die Methodenaufrufe der Unit LesSQL wurden aus Gründen der Kompatibilität identisch mit denen der Les erstellt. Die beiden Dateien sollten auch so erhalten bleiben.
Bislang wurden die Units immer je nach Anwendungsfall eingebunden und kompiliert.

Nun gibt es eine neue Klasse „TLese“ als Wrapper, die den Zugriff auf die Les/LesSQL-Units vereinfacht:

Delphi-Quellcode:

// LeseDatei aufrufen.
Function TLese.getDatei: Boolean;

Ich hätte nun gerne eine Möglichkeit, je nach Anwendungsfall die passende Unit in der Klasse TLese einzubinden (z.B. mittels Parameter im Konstruktor).
Gibt es hierfür eine Lösung? Vielleicht per Compiler-Direktive?

[mkinzler]

Könnte man durch bedingte Compilierung lösen

Delphi-Quellcode:

uses 
   ...,
{$IFDEF USE_SQL} LesSQL{$ELSE}Les{$ENDIF}, ...

[DeddyH]

Aber das funktioniert nur zur Designtime und nicht durch Konstruktor-Parameter oder ähnliches.

[Bernhard Geyer]

Schlagworte wären hier Bridge Pattern oder Abstract Factory

[Der schöne Günther]

Soweit ich das verstehe ist doch das eigentliche Problem, dass Delphi es nicht erlaubt, eine "Unit an sich" zu referenzieren- Es gibt keinen Typ dafür. Somit kann man nicht dynamisch sagen "Unit A" oder "Unit B".

Da beide Units doch schon so schön aufgebaut sind, wäre es doch eigentlich die geringste Arbeit, die beiden endlich in eine Klasse mit gemeinsamer Schnittstelle zu packen, oder?
Alternativ je eine Klasse (wieder mit gemeinsamer Schnittstelle) als Fassade für eine Unit wenn man die alte Unit-Struktur noch woanders verwenden möchte.

[nuclearping]

Du kannst die Funktionen in Les und LesSQL in Klassen auslagern. Zum Beispiel kannst du hier auch auf Vererbung zurückgreifen.

Delphi-Quellcode:

unit LesBase;

interface

type
  TLesBase = class
  public
    function LeseDatei(Name: String): String; virtual; abstract;
  end;

  TLesBaseClass = class of TLesBase;

implementation

end.

Delphi-Quellcode:

unit Les;

interface

uses
  LesBase;

type
  TLes = class(TLesBase)
  public
    function LeseDatei(Name: String): String; override;
  end;

implementation

function TLes.LeseDatei(Name: String): String;
begin
  ...
end;

end.

Delphi-Quellcode:

unit LesSQL;

interface

uses
  LesBase;

type
  TLesSQL = class(TLesBase)
  public
    function LeseDatei(Name: String): String; override;
  end;

implementation

function TLesSQL.LeseDatei(Name: String): String;
begin
  ...
end;

end.

Und in dem Wrapper kannst du dann im Constructor die entsprechende Les-Klasse übergeben.

Delphi-Quellcode:

unit Lese;

interface

uses
  LesBase;

type
  TLese = class
    constructor Create(ALesClass: TLesBaseClass);
    destructor Destroy; override;
  private
    FLesClass: TLesBaseClass;
  public
    function getDatei: Boolean;
  end;

implementation

constructor TLese.Create(ALesClass: TLesBaseClass);
begin
  FLesClass := ALesClass.Create;
end;

destructor TLese.Destroy;
begin
  FLesClass.Free;
  inherited;
end;

function TLese.getDatei: Boolean;
begin
  Result := Length(FLesClass.LeseDatei('...') > 0);
end;

end.

Anwendung:

Delphi-Quellcode:

unit Form1;

interface

...

implementation

uses
  Lese, Les, LesSQL;

...

procedure TForm1.Button1Click(Sender: TObject);
var
  LesClass: TLesBaseClass;
begin
  case FUseClass of
    clLes:
      LesClass := TLes;
    clLesSQL:
      LesClass := TLesSQL;
  end;
  FLese := TLese.Create(LesClass);
  try
    if FLese.getDatei then
      ShowMessage('Juhu! \o/')
    else
      ShowMessage('Oh Noes! D:');
  finally
    FLese.Free;
  end;
end;

...

end.

Ungetestet. Aber das Prinzip sollte klar sein.

[ernschd]

So weit mal vielen Dank an alle

Ich schaue mir mal an, wie ich das umsetzen kann.

[Bernhard Geyer]

Zitat von Der schöne Günther:

Soweit ich das verstehe ist doch das eigentliche Problem, dass Delphi es nicht erlaubt, eine "Unit an sich" zu referenzieren- Es gibt keinen Typ dafür. Somit kann man nicht dynamisch sagen "Unit A" oder "Unit B".

Über Packages (und eigentlich wieder Klassen/Interfaces) wäre das möglich.
Ich würde das aber nicht empfehlen das dynamisch darüber zu machen.

Ebenfalls wäre ein reine DLL möglich die jeweils die gleichen exportierten Funktionen hat.