Eine Frage zu Generics in generischen Listen

[Catweasel77]

Hallo :)

Ich bin gerade dabei mich mit Generics zu beschaeftigen. Zum Teil klappt das auch ganz gut, aber ein kleines Problem hab ich noch bei dem ich nicht durchblicke. Hoffentlich kann mir jemand weiterhelfen und ein paar Tipps geben.

Nehmen wir an ich moechte eine Klasse fuer Datentypen haben mit der Faehigkeit aus einem Stream zu lesen, bzw. in Einen zu schreiben und den Wert als string auszugeben. Dazu habe ich eine generische Klasse erstellt und die jeweiligen Methoden zur Stringumwandlung (und beim string Typ das streaming) ueberschrieben:

Delphi-Quellcode:

unit UDataTypes;

interface

uses
  SysUtils, Classes;

type
  IDataIO=interface(IInterface)
    function GetVString: string;
    procedure LoadFromStream(AStream:TFileStream);
    procedure SaveToStream(AStream:TFileStream);
    property VString : string read GetVString;
  end;

type
  TDataTypeGeneric<TDataType>=class(TInterfacedObject, IDataIO)
  private
    FData : TDataType;
    function GetData: TDataType;
    procedure SetData(const Value: TDataType);
  protected
    function GetVString: string;virtual;abstract;
  public
    procedure LoadFromStream(AStream:TFileStream);virtual;
    procedure SaveToStream(AStream:TFileStream);virtual;
    property Data : TDataType read GetData write SetData;
    property VString : string read GetVString;
  end;

  TIntegerClass=class(TDataTypeGeneric<integer>)
  private
  protected
    function GetVString: string;override;
  public
  end;

  TFloatClass=class(TDataTypeGeneric<extended>)
  private
  protected
    function GetVString: string;override;
  public
  end;

  TBooleanClass=class(TDataTypeGeneric<boolean>)
  private
  protected
    function GetVString: string;override;
  public
  end;

  TStringClass=class(TDataTypeGeneric<string>)
  private

  protected
    function GetVString: string;override;
  public
    procedure LoadFromStream(AStream:TFileStream);override;
    procedure SaveToStream(AStream:TFileStream);override;
  end;


implementation

{ TDataTypeGeneric<TDataType> }


function TDataTypeGeneric<TDataType>.GetData: TDataType;
begin
Result := FData;
end;

procedure TDataTypeGeneric<TDataType>.LoadFromStream(AStream: TFileStream);
begin
AStream.Read(FData,SizeOf(FData));
end;

procedure TDataTypeGeneric<TDataType>.SaveToStream(AStream: TFileStream);
begin
AStream.Write(FData,SizeOf(FData));
end;

procedure TDataTypeGeneric<TDataType>.SetData(const Value: TDataType);
begin
FData := Value;
end;


{ TIntegerClass }

function TIntegerClass.GetVString: string;
begin
Result := IntToStr(FData);
end;


{ TFloatClass }

function TFloatClass.GetVString: string;
begin
Result := FloatToStr(FData);
end;


{ TBooleanClass }

function TBooleanClass.GetVString: string;
begin
Result := BoolToStr(FData,true);
end;


{ TStringClass }

function TStringClass.GetVString: string;
begin
Result := FData;
end;

procedure TStringClass.LoadFromStream(AStream: TFileStream);
var
size : longint;
begin
AStream.Read(size,SizeOf(size));
setlength(FData,size div 2);
AStream.Read(PChar(FData)^,size);
end;

procedure TStringClass.SaveToStream(AStream: TFileStream);
var
size : longint;
begin
size := length(FData) * SizeOf(char);
AStream.Write(size,SizeOf(size));
AStream.Write(PChar(FData)^,size);
end;

end.

Das klappt auch soweit ganz gut.
Jetzt moechte ich aber eine generische Liste fuer objekte dieses Generischen Typs definieren. Diese Liste soll auch eine Methode enthalten die ein neues Objekt erstellt und der Liste hinzufuegt. Das Problem das ich habe ist die Deklaration der Klasse:

Delphi-Quellcode:

unit UListTypes;

interface

uses
  Classes, Contnrs, UDataTypes;

type
  TListTypeGeneric<TDataObjectType:TDataTypeGeneric<TDataType>,IDataIO,constructor>=class(TObjectList)
  private
    function GetElement(Index: integer): TDataObjectType;
    procedure SetElement(Index: integer; const Value: TDataObjectType);
  protected
    function GetVString: string;virtual;
  public
    function AddNewElement : TDataObjectType;
    procedure LoadFromStream(AStream:TFileStream);
    procedure SaveToStream(AStream:TFileStream);
    property Element[Index:integer] : TDataObjectType read GetElement write SetElement;
    property VString : string read GetVString;   
  end;


implementation

{ TListTypeGeneric<TDataObjectType> }

function TListTypeGeneric<TDataObjectType>.AddNewElement: TDataObjectType;
begin
Result := TDataObjectType.Create;
Add(TDataObjectType(Result));
end;

function TListTypeGeneric<TDataObjectType>.GetElement(Index: integer): TDataObjectType;
begin
Result := TDataObjectType(Items[Index]);
end;

procedure TListTypeGeneric<TDataObjectType>.LoadFromStream(AStream: TFileStream);
var
Size,x : longint;
begin
AStream.Read(FSize,SizeOf(Size));
for x := 0 to Size-1 do
  AddNewElement.LoadFromStream(AStream);
end;

procedure TListTypeGeneric<TDataObjectType>.SaveToStream(AStream: TFileStream);
var
Size,x : longint;
begin
Size := Count;
AStream.Write(FSize,SizeOf(Size));
for x := 0 to Size-1 do
  Element[0].SaveToStream(AStream);
end;

procedure TListTypeGeneric<TDataObjectType>.SetElement(Index: integer;const Value: TDataObjectType);
begin
Items[Index] := Value;
end;

function TListTypeGeneric<TDataObjectType>.GetVString: string;
var
x : longint;
begin
AStream.Write(FSize,SizeOf(Size));
for x := 0 to Count-1 do
Result := Result + Element[x].VString + ',';
end;

end.

Ich hatte das so verstanden das ich bei Generics ein Interface bereitstellen muss wenn ich Methoden vwerwenden will damit sich der Compiler sicher ist das es diese Methoden gibt. Hab auch den Parameter auf Klasse eingeschraenkt und dem Compiler versichert das es einen Constructor gibt. Wenn ich allerdings das Interface einfueger dann meckert er das das Interface kein 'Create kennt'. Und beim constraint 'class' beschwert er sich das TObject kein 'SaveToStream()' kennt... :shock:
Das Dumme ist das sich die IDE manchmal direkt beim compilieren/parsen aufhaengt... :|

Also wie definiert man das richtig, so das es das macht was ich moechte :?:

Fuer jede Hilfe bin ich dankbar :)

Cheers,
Klaus

PS: Ich benutze Delphi 10.3.1 (aber das ist nicht auswaehlbar im Threadformular)

[jaenicke]

Als erstes fällt mir auf:
Du arbeitest mit Generics, benutzt aber die nicht generische Objektliste mit Casts?!? :shock:

Ich glaube du meintest es so in etwa wie im Anhang:

Delphi-Quellcode:

  TListTypeGeneric<TDataObjectType; TListType: TDataTypeGeneric<TDataObjectType>, IDataIO, constructor> = class(TObjectList<TListType>)
...

Benutzung:

Delphi-Quellcode:

var
  Test: TListTypeGeneric<Integer, TIntegerClass>;
begin
  Test := TListTypeGeneric<Integer, TIntegerClass>.Create;
  try
    Test.AddNewElement.Data := 42;
    ShowMessage(Test.Element[0].ToString); // Oder: Test.Items[0].Data.ToString
  finally
    Test.Free;
  end;

// EDIT:
Das geht aber noch schöner. Ich habe beruflich ein ähnliches Problem gehabt und habe schlicht ein generisches Dictionary benutzt, in dem man Behandlungsroutinen registrieren kann. Auf diese Weise brauchte ich in die konkrete Logik bei der generischen Nutzung keinen weiteren Aufwand mehr hineinstecken solange in dem Dictionary für den jeweiligen Datentyp eine Behandlung hinterlegt war.

[Catweasel77]

@jaenicke

Vielen Dank fuer die schnelle Antwort.

Zitat:

Ich glaube du meintest es so in etwa wie im Anhang:

Ja, das sieht schon gut aus. Eine Sache ist aber noch unklar :)

Warum gibt 'Liste.Element[Index]' direkt den DatenType zurueck und nicht das DatenTyp Objekt.

Zum Beispiel:

Delphi-Quellcode:

type
  TIntegerList = TListTypeGeneric<longint, TIntegerClass>;

var
  Test: TIntegerList;
begin
  Test := TIntegerList.Create;
  try
    Test.AddNewElement.Data := 42;         // AddNewElement liefert TIntegerClass zurueck
    ShowMessage(Test.Element[0].VString);  // Element[0] liefert direkt einen Integer, kein TIntegerClass Objekt
  finally
    Test.Free;
  end;
end;

Die Element propery ist ja deklariert als:

Delphi-Quellcode:

property Element[index: integer]: TDataObjectType read GetElement write SetElement;

Die eigene Methode VString waere schon wichtig wenn der DatenType ein record ist. Oder ich einen TColor Wert z.b. als 'Red:125 Green:65 Blue:69' ausdruecken will...

Ich stelle mir das so or das ich mit Liste.Element[Index].Data auf den Wert zugreife und mit VString einen selbstdefinierten String zurueckgebe.
ToString() liefert ja bei booleans '-1'.

Also die Preisfrage : Wieso bekomme ich kein Objekt zurueck? (Und wie doch?)

Waere toll wenn du mir das noch erklaeren koenntest :)

Im Voraus vielen Dank :)

Cheers,
Klaus

[Rudy Velthuis]

Zitat:

Zitat von Catweasel77 (Beitrag 1431600)

Hallo :)

Ich bin gerade dabei mich mit Generics zu beschaeftigen. Zum Teil klappt das auch ganz gut, aber ein kleines Problem hab ich noch bei dem ich nicht durchblicke. Hoffentlich kann mir jemand weiterhelfen und ein paar Tipps geben.

Wenn ich mir deinen Code so ansehe, frage ich mich, warum du eigentlich Generics brauchst. Du benuztz sie, soweit ich sehen kann, ja gar nicht. Das Gleiche kann man mit normalen, nicht-generischen Klassen machen. Generics sollten benuzt werden, wenn man immer den gleichen Code haben will, nur mit anderen Basis-Typen.

Soweit ich sehen kann, hast du für jeden Typ anderen Code.

[Catweasel77]

Zitat:

Wenn ich mir deinen Code so ansehe, frage ich mich, warum du eigentlich Generics brauchst. Du benuztz sie, soweit ich sehen kann, ja gar nicht. Das Gleiche kann man mit normalen, nicht-generischen Klassen machen. Generics sollten benuzt werden, wenn man immer den gleichen Code haben will, nur mit anderen Basis-Typen.

Wieso? Ich benutze doch Generics. TDataTypeGeneric ist der generische Typ. Der code fuer die Data property und das streaming ist das selbe.
Lediglich die VString property ist fuer jede Klasse anders da jeder Typ ne andere Umwandlung zu string hat (IntToStr, FloatToStr, etc.).
Also Klassen mit nem Data member das gestreamt werden kann, mit unterschiedlichen Basistypen.
Ich will nur nicht die Arbeit haben die Unit mit der Integerklasse zu kopieren und jedes 'longint' durch ein 'extended' und jedes 'TIntegerClass' mit 'TFloatClass' auszutauschen. Das waere der nicht-generic Weg.
Und dann solls dazu Listen geben die eben solche Typen verwalten.

[Rudy Velthuis]

Zitat:

Zitat von Catweasel77 (Beitrag 1431615)

Zitat:

Wenn ich mir deinen Code so ansehe, frage ich mich, warum du eigentlich Generics brauchst. Du benuztz sie, soweit ich sehen kann, ja gar nicht. Das Gleiche kann man mit normalen, nicht-generischen Klassen machen. Generics sollten benuzt werden, wenn man immer den gleichen Code haben will, nur mit anderen Basis-Typen.

Wieso? Ich benutze doch Generics. TDataTypeGeneric ist der generische Typ. Der code fuer die Data property und das streaming ist das selbe.
Lediglich die VString property ist fuer jede Klasse anders da jeder Typ ne andere Umwandlung zu string hat (IntToStr, FloatToStr, etc.).
Also Klassen mit nem Data member das gestreamt werden kann, mit unterschiedlichen Basistypen.
Ich will nur nicht die Arbeit haben die Unit mit der Integerklasse zu kopieren und jedes 'longint' durch ein 'extended' und jedes 'TIntegerClass' mit 'TFloatClass' auszutauschen. Das waere der nicht-generic Weg.
Und dann solls dazu Listen geben die eben solche Typen verwalten.

Du benutzt die Syntax.

Aber, wenn ich es richtig sehe, kann man das, was du machst, genauso gut ohne machen.

[Catweasel77]

Zitat:

Aber, wenn ich es richtig sehe, kann man das, was du machst, genauso gut ohne machen.

Naja, so gesehen kann man alles was man mit Generics machen kann auch ohne machen.

Stell dir diese Klasse vor:

Delphi-Quellcode:

type
  TIntegerClass=class(TObject)
  private
    FData : longint;
    function GetData: longint;
    procedure SetData(const Value: longint);
    function GetVString: string;
  public
    procedure LoadFromStream(AStream:TFileStream);
    procedure SaveToStream(AStream:TFileStream);
    property Data : longint read GetData write SetData;
    property VString : string read GetVString;
  end;

Und das eben als Generic fuer beliebige Typen... Ich will aber nicht den Quellcode duplizieren und einfach nur den typ ersetzen...
Dasselbe bei der Liste

Die IntegerListe waere dann das hier (aber als Generic fuer alle Typen die ich aus dem datenTyp Generic bastel):

Delphi-Quellcode:

type
  TIntegerList=class(TObjectList)
  private
    function GetElement(Index: integer): TIntegerClass;
  public
    function AddNewElement : TIntegerClass;
    procedure LoadFromStream(AStream:TFileStream);
    procedure SaveToStream(AStream:TFileStream);
    property Element[Index:integer] : TIntegerClass read GetElement;
  end;

Das klappt ja auch. Nur die Liste, bzw. jetzt die Element[] property gibt mir noch raetsel auf...

[jaenicke]

Zitat:

Zitat von Catweasel77 (Beitrag 1431609)

Ja, das sieht schon gut aus. Eine Sache ist aber noch unklar :)

Warum gibt 'Liste.Element[Index]' direkt den DatenType zurueck und nicht das DatenTyp Objekt.

Weil es so programmiert ist. Wenn du den Typ selbst gar nicht möchtest, entferne einfach die eigene Eigenschaft Element und benutze nur die vorhandene Eigenschaft Items wie ich es in dem Kommentar auch angedeutet habe.

[Catweasel77]

Zitat:

Wenn du den Typ selbst gar nicht möchtest, entferne einfach die eigene Eigenschaft Element und benutze nur die vorhandene Eigenschaft Items

Ja, irgendwie war ich der Meinung Items[] wuerde mir nur ein TObject zurueckgeben.
Wie gesagt, ist mein erster Gehversuch mit Generics :)

[Schokohase]

Zitat:

Zitat von Catweasel77 (Beitrag 1431656)

Zitat:

Wenn du den Typ selbst gar nicht möchtest, entferne einfach die eigene Eigenschaft Element und benutze nur die vorhandene Eigenschaft Items

Ja, irgendwie war ich der Meinung Items[] wuerde mir nur ein TObject zurueckgeben.
Wie gesagt, ist mein erster Gehversuch mit Generics :)

Die Eigenschaft

Delphi-Quellcode:

Items

liefert doch ein

Delphi-Quellcode:

TObject

zurück (geerbt von

Delphi-Quellcode:

TObjectList

)
Die Eigenschaft

Delphi-Quellcode:

Element

liefert den generischen Typen zurück (weil du es so programmiert hast)