Generisches Alias von TFrame

[freimatz]

Oder ich...
Ich wüsste jetzt woher der compiler wissen soll dass Du nicht TObstKorb<TBanane> sondern TBananenKorb haben willst.
Vielleicht vergisst Du mal die Generics und beschreibst mal welches Anwender-Problem Du lösen willst.

[hzzm]

Zitat von freimatz:

Vielleicht vergisst Du mal die Generics und beschreibst mal welches Anwender-Problem Du lösen willst.

Nachdem ich meine Struktur nun wieder ein ganzes Stueck von generics weggebracht habe, versuche ich mal mein Problem grundsaetzlich und vereinfacht zu beschreiben:

Ich habe 2 Objekt-Typen (nennen wir die Typen mal A1 und A2), die ein paar gleiche und ein paar unterschiedliche Variablen und Funktionen besitzt.
Daher erben sie die allgemeinen Eigenschaften vom Typ A.
Die Eigenschaften, die gleich sind (von A geerbt), werden von vielen anderen Units im Programm benoetigt und manipuliert.
Das ganze Programm verwendet insgesamt nur entweder A1 oder A2, nie beide Typen.

Ich habe ein Adapter-Objekt, das die meisten Manipulationen (sowohl Typ A, A1 und A2) daran vornimmt. Die anderen Units benoetigen immer nur Typ A allgemein, nie die Eigenschaften von A1 und A2.

Daher hat mein Adapter einen Getter, der Typ A rausgibt, aber auch viele andere Getter, die einzelne A-Eigenschaften an andere Units rausgeben.

Ich will vermeiden, dass ich 2 unterschiedliche A1 A2 im Adapter ablege, sprich vermeiden, dass ich alle Getter/Setter/etc des Adapters zwiespalten muss, obwohl nahezu identischer Code ausgefuehrt wird.

[himitsu]

Delphi-Quellcode:

type
  TSpeziellerFrame<T2> = class(TFrame)
    [...]
  End;

  TKanne<T1> = TSpeziellerFrame<T1>;

Hab mal das T unterschiedlich benann, als T1 und T2, damit man besser sieht, was direkt zusammen hängt.

Zitat:

TKanne<TObjectList> = class( TSpeziellerFrame; ) // ohne class() kompilierts gar nicht

Wegen dem Semikolon?

Oder was soll da nicht gehn?
Es wäre bestimmt hilfreich, wenn jemand (ich schau jetzt mal niemanden speziellen an) bei sowas die Fehlermeldung kopieren würde.


PS: Vom Verständnis her, macht es sich IMHO ungünstig, wenn bei type TIrgendwas<Bezeichner> = ...; der "Bezeichner" genau wie ein "existierendet" Typ/Klasse benannt wird ... Verwechslungsgefahr.

[hzzm]

Zitat von himitsu:

Es wäre bestimmt hilfreich, wenn jemand (ich schau jetzt mal niemanden speziellen an) bei sowas die Fehlermeldung kopieren würde.

Der Semikolon-Fehler war nur im Beispiel, ich habe den Code leider schon laenger nicht mehr so drin.

Ich hab jetzt alles nochmal 10x hin- und hergedreht und denke einfach, ich muss einen Strukturfehler bei den generischen Definitionen machen.
Das kann doch nicht sein, dass das nicht geht. Ich nehme noch einen Anlauf und versuche, meine Struktur zwar simpel, aber so genau wie moeglich darzustellen.

Vielen Dank auf jeden Fall schonmal fuer Eurer aller Bemuehungen!

Delphi-Quellcode:

unit Schritt;

interface

uses
  Zugabe, SysUtils, CleanFloats;

type
  PSchritt = ^TSchritt;
  TSchritt = class
    Temperatur,
    Zeit,
    Gewicht: String[5];

    Zugaben: TZugaben;
  public
    procedure WriteToStream(Offset: Word); virtual; abstract;
    procedure ReadFromStream(Offset: Word); virtual; abstract;
  End;
  TSchritte = TArray<TSchritt>;

  PKSchritt = ^TKSchritt;
  TKSchritt = class(TSchritt)
    Breite,
    Wasser: String[5];
  public
    procedure WriteToStream(Offset: Word); override;
    procedure ReadFromStream(Offset: Word); override;
  End;
  TKSchritte = TArray<TKSchritt>;

  PMSchritt = ^TMSchritt;
  TMSchritt = class(TSchritt)
    Viskositaet,
    Intervall: String[5];
  public
    procedure WriteToStream(Offset: Word); override;
    procedure ReadFromStream(Offset: Word); override;
  End;
  TMSchritte = TArray<TMSchritt>;
  
  
  TZugabe = packed Record
    Name: String[40];
    Menge: String[5];
    Einheit: String[5];
  end;
  TZugaben = TArray<TZugabe>;

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;

Delphi-Quellcode:

unit Programm;

interface

uses
  SysUtils, ExtCtrls, Rezept, Schritt, Vcl.Forms, Observer, KProgrammView, MProgrammView;

type
  TProgrammModel<T: TSchritt> = class
  public
    Rezept: TRezept<T>;
//    Rezept: TKRezept;  // So geht es, generisch nicht!
    constructor Create{(AOwner: TComponent)};
  End;

  TProgrammAdapter<T: TSchritt> = class(TInterfacedObject, IProgrammAdapter)
  private
    Model: TProgrammModel<T>;
    IView: IProgrammView;
  public
    Notifier: TObserverSubject;
    constructor Create(AOwner: TComponent; IAView: IProgrammView; AModel: TProgrammModel<T>);
    procedure WriteToStream(Sender: TObject);
    procedure ReadCSV(Filename: String);
    procedure ScaleIngredients(Percent: Integer);
    function GetRecipeName: String;
    function GetRecipeFilename: String;
    procedure SetRecipe(ARezept: TRezept<T>);
  End;
  
implementation

constructor TProgrammAdapter<T>.Create(AOwner: TComponent; IAView: IProgrammView; AModel: TProgrammModel<T>);
begin
  IView := IAView;
  Steps := IView.GetSteps;
  Model := AModel;
end;

procedure TProgrammAdapter<T>.ReadCSV(Filename: String);
begin
//  if Model.Rezept <> nil then
//    Model.Rezept.Free;
//  if TypeInfo(T) = TypeInfo(TKSchritt) then
//    Model.Rezept := TRezept<TKSchritt>.Create
//  else if TypeInfo(T) = TypeInfo(TMSchritt) then
//    Model.Rezept := TRezept<TMSchritt>.Create;

  Model.Rezept.ReadCSV(Filename); // Abstrakter Fehler!
end;

[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.