Generisches Alias von TFrame

[Stevie]

Zitat von hzzm:

Delphi-Quellcode:

unit Rezept;

interface

uses
  Schritt, Zugabe, Hashes;

type
  TRezept<T: TSchritt> = class
    Dateiname: String[70];
    Name,
    Gruppe,
    Datum: String[40];
    Schritte: TArray<T>;
    procedure SchrittLoeschen(const Index: Integer);
    procedure ReadCSV(Dateiname: String); virtual; abstract;
    procedure WriteCSV(Dateiname: String); virtual; abstract;
    procedure LeereSchritt(var Index: Integer); virtual; abstract;
  End;

  PKRezept = ^TKRezept;
  TKRezept = class(TRezept<TKSchritt>)
    procedure ReadCSV(Dateiname: String); override;
    procedure WriteCSV(Dateiname: String); override;
    procedure LeereSchritt(var Index: Integer); override;
  End;

  PMRezept = ^TMRezept;
  TMRezept = class(TRezept<TMSchritt>)
    procedure ReadCSV(Dateiname: String); override;
    procedure WriteCSV(Dateiname: String); override;
    procedure LeereSchritt(var Index: Integer); override;
  End;

Zitat von Stevie:

Hat aber kaum mit dem Problem hier zu tun, dass abhängig von einem Typen von T eine abstrakte Methode plötzlich was ausführen könnte. Polymorphie hat in dem Zusammenhang nix mit Generics zu tun.

Ich seh in dem Code nich die Stelle, wo du die Rezept Instanz erstellst, aber gemäß dieser Unit oben bist du dort nicht mehr generisch, sondern leitest von einer generischen Spezialisierung ab, da die generische Klasse nunmal abstrakte Methoden hat - deshalb habe ich meinen Satz von vorher hier nochmal zitiert.

[hzzm]

Zitat von Stevie:

Ich seh in dem Code nich die Stelle, wo du die Rezept Instanz erstellst, aber gemäß dieser Unit oben bist du dort nicht mehr generisch, sondern leitest von einer generischen Spezialisierung ab, da die generische Klasse nunmal abstrakte Methoden hat - deshalb habe ich meinen Satz von vorher hier nochmal zitiert.

Verstehe.
Gemaess meinem Kommentar im Code // Rezept: TKRezept; // So geht es, generisch nicht! , kann ich das Model.Rezept als TKRezept deklarieren und mit TKRezept.Create; initialisieren, dann funktioniert natuerlich alles (solange der ProgrammAdapter als TProgrammAdapter<TKSchritt> erstellt wird).

Aber das widerspricht ja dem Zweck dieser generischen Struktur, ich will ja auch das Rezept in generischer Abhaengigkeit vom Rest erstellen. Genau das ist der Punkt, an dem ich scheitere; wenn ich im Model 2 Variationen, KRezept: TKRezept; und MRezept: TMRezept; ablegen muss, die ich konditional bestelle, bin ich ja in genau meiner Zwickmuehle, dass ich viel code zwiespalten muss, obwohl er eigentlich gleich ist. Eine meiner Anfangs-Motivationen zu generics zu greifen.

Gibt es zu diesem Problem innerhalb der Delphi generics ueberhaupt eine Loesung?

Delphi-Quellcode:

constructor TProgrammModel<T>.Create;
begin
  // Rezept := TKRezept.Create; // geht (Deklaration auch als Rezept: TKRezept;)
  // Rezept := TKRezept.Create; // scheitert bei Deklaration als Rezept: TRezept<T>; natuerlich
  Rezept := TRezept<T>.Create; // geht wie besprochen nicht: Abstrakte Fehler
end;

[freimatz]

Nein, innerhalb der Delphi Generics nicht. Dazu ist dann die Polymorphie da.

[Stevie]

Irgendwo in der Struktur muss ein Teil rein, was anhand des konkreten Typs von T die richtige nicht generische Klasse zum Lesen/Speichern/Whatever erstellt, sofern dieser Code nicht über einen generischen Algo gelöst werden kann. Ich würde mir also überlegen, das CSV Zeugs nicht per Ableitung sondern Aggregation zu koppeln.

Ja, irgendwo im generischen Code muss dann eine if-then-else "Leiter" wie zuvor schon gezeigt rein.

Die Aggregation kann dann per API die Basisklasse nutzen aber je nach Implementierung weiß sie dann, dass die TFrucht Instanzen, die da rein oder raus gehen Äpfel oder Bananen sind.

Aus Erfahrung würd ich dir raten, das Design nochmal zu überdenken und genau zu schauen, wo du strikte Typensicherheit haben willst und wo du lieber mit einer nicht generischen Basisklasse arbeitest die auf Instanzen von TSchritt arbeiten. Man kann dann auch problemlos eine sehr dünne generische Schicht auf eine solche nicht generische Klasse oben drauf setzen (oder per Interface implementieren), so dass entsprechende Consumer typensicher arbeiten. Tiefe generische Hierarchien, bei denen dann noch die Logik abhängig vom generischen Typenparameter ist, enden selten gut.

[Uwe Raabe]

Zitat von Stevie:

Ja, irgendwo im generischen Code muss dann eine if-then-else "Leiter" wie zuvor schon gezeigt rein.

Ohne das jetzt näher analysiert zu haben - wäre das nicht was für das Visitor-Pattern?

[Stevie]

Zitat von Uwe Raabe:

Zitat von Stevie:

Ja, irgendwo im generischen Code muss dann eine if-then-else "Leiter" wie zuvor schon gezeigt rein.

Ohne das jetzt näher analysiert zu haben - wäre das nicht was für das Visitor-Pattern?

Dafür müsste man der overload resolution in Generics vertrauen, und das tu ich nicht.

Edit: Hast recht, ich hab verkehrt herum gedacht, aber so sollte das funktionieren (auf Erstellen von Objekten wo nicht benötigt hab ich für das Beispiel verzichtet):

Delphi-Quellcode:

{$APPTYPE CONSOLE}

type
  TFruchtKorbFactory = class;

  TFrucht = class
    function GibFruchtKorb(const factory: TFruchtKorbFactory): TObject; virtual; abstract;
  end;

  TBanane = class(TFrucht)
    function GibFruchtKorb(const factory: TFruchtKorbFactory): TObject; override;
  end;

  TApfel = class(TFrucht)
    function GibFruchtKorb(const factory: TFruchtKorbFactory): TObject; override;
  end;

  TFruchtKorbFactory = class
    function CreateInstance(const banane: TBanane): TObject; overload;
    function CreateInstance(const apfel: TApfel): TObject; overload;
  end;

  TGenericDings<T: TFrucht, constructor> = class
    procedure Wuppdi;
  end;

{ TBanane }

function TBanane.GibFruchtKorb(const factory: TFruchtKorbFactory): TObject;
begin
  Result := factory.CreateInstance(Self);
end;

{ TApfel }

function TApfel.GibFruchtKorb(const factory: TFruchtKorbFactory): TObject;
begin
  Result := factory.CreateInstance(Self);
end;

{ TFruchtKorbFactory }

function TFruchtKorbFactory.CreateInstance(const apfel: TApfel): TObject;
begin
  Writeln('erstelle fruchtkorb für apfel');
end;

function TFruchtKorbFactory.CreateInstance(const banane: TBanane): TObject;
begin
  Writeln('erstelle fruchtkorb für banane');
end;

{ TGenericDings<T> }

procedure TGenericDings<T>.Wuppdi;
var
  frucht: T;
  factory: TFruchtKorbFactory;
begin
  frucht := T.Create; // das hier wird für den virtual dispatch von GetWhatever benötigt
  frucht.GibFruchtKorb(factory);

  // Was hier nicht gehen würde wäre: factory.CreateInstance(frucht);
end;

var
  apfeldings: TGenericDings<TApfel>;
  bananendings: TGenericDings<TBanane>;
begin
  apfeldings.Wuppdi;
  bananendings.Wuppdi;
end.