Eine Generics TObjectList<T> als Parameter

[RWarnecke]

Hallo zusammen,

ich habe eine generics ObjectList so definiert

Delphi-Quellcode:

TCustomObjectList<T: class> = class(TObjectList<T>)

und als Variable so definiert

Delphi-Quellcode:

ZahlungsartList : TCustomObjectList<TZahlungsart>;

. Das funktioniert auch wunderbar. Ich kann ja die Generic-ObjectList so wie ich Sie als Variable deklariert habe übergeben :

Delphi-Quellcode:

procedure foobar(liste: CustomObjectList<TZahlungsart>);

. Wie kann ich auch das <TZahlungsart> als Parameter definieren in dem Procedure-Kopf ?

[daywalker9]

Delphi-Quellcode:

type
  TFoo = class
    procedure bar<T>(meineList:Tobjectlist<T>);
  end;

Meinst Du sowas?

[RWarnecke]

Nein, ich möchte in einer externen eigenständigen Funktion auf Werte von den Generics-ObjectListen zugreifen. In dieser Funktion soll dann anhand der übergebenen Liste entschieden werden, was gemacht werden soll.

Der Pseudocode soll zeigen, was ich machen möchte :

Delphi-Quellcode:

interface

type
  TZahlungsart = class 
  private
    {...}
  public
    {...}
  end; 

  TPostleitzahlen = class 
  private
    {...}
  public
    {...}
  end; 

  TCustomObjectList<T: class> = class(TObjectList<T>)
  private
    {...}
  public
    {...}
  end; 

var
  ZahlungsartList : TCustomObjectList<TZahlungsart>;
  Postleitzahlen  : TCustomObjectList<TPostleitzahlen>;

implementation

procedure Test(ObjectList: ??????);
var
  tmpName : string;
begin
  tmpName := ObjectList.Items[Counter].<Feld>;
end:

Der Aufruf aus der Form soll dann zum Beispiel so aussehen :

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
begin
  procedure Test(ZahlungsartList);
end;

Statt Zahlungsart kann da auch Postleitzahlen stehen.

[Uwe Raabe]

Als globale Prozedur wird das nicht gehen, lediglich als Methode eines Records oder einer Klasse:

Delphi-Quellcode:

  TDummy = record
    class procedure Test<T:class>(ObjectList: TCustomObjectList<T>); static;
  end;


  TDummy.Test<TZahlungsart>(ZahlungsartList);
  TDummy.Test<TPostleitzahlen>(Postleitzahlen);

[himitsu]

oder so, wem das besser gefällt (kommt aber, von der Verwendung her, auf's Selbe raus ... ich find Record auch schöner, aber Klasse ist ableitbar/erweiterbar)

Delphi-Quellcode:

  TDummy = class abstract  // ältere Delphis: wenn's nicht geht, dann abstract einfach weglassen 
    class procedure Test<T:class>(ObjectList: TCustomObjectList<T>); static;
  end;

Schade das emba nicht auf mich hört und bei generischen Funktionen einfach eine DummyKlasse/Record drumzupacken, wenn die es nicht schaffen es ihrem Compiler beizubringen, dßa es generische Funktion gibt.

[RWarnecke]

Hm, das ist nicht ganz das was ich wollte. Aber ok, dann muss ich ein bisschen umkoordinieren.

[Stevie]

Da wir einen Typconstraint auf class haben, können wir davon ausgehen dass jedes T eine Klasse ist.
Somit können wir auch gefahrlos einen Hardcast auf TCustomObjectList<TObject> machen (Stichwort: Kovarianz).

Bei der Instanzierung einer Liste, merken wir uns, von welchem Typ T ist.
Dies muss auf Instanzebene gespeichert werden, damit wir auch nach dem zuvor erwähnten Hardcast noch die richtige Klasse herausbekommen.

Delphi-Quellcode:

type
  TCustomObjectList<T: class> = class(TObjectList<T>)
  private
    FItemClass: TClass;
  public
    constructor Create(AOwnsObjects: Boolean = True); overload;
    function AsNonGeneric: TCustomObjectList<TObject>;
    property ItemClass: TClass read FItemClass;
  end;

  TCustomObjectList = TCustomObjectList<TObject>;

function TCustomObjectList<T>.AsNonGeneric: TCustomObjectList<TObject>;
begin
  Result := TCustomObjectList<TObject>(Self);
end;

constructor TCustomObjectList<T>.Create(AOwnsObjects: Boolean);
begin
  inherited Create(AOwnsObjects);
  FItemClass := T;
end;

procedure Test(ObjectList: TCustomObjectList);
begin
  Writeln(objectList.ItemClass.ClassName);
end;

var
  ZahlungsartList: TCustomObjectList<TZahlungsart>;
  Postleitzahlen: TCustomObjectList<TPostleitzahlen>;
begin
  ZahlungsartList := TCustomObjectList<TZahlungsart>.Create;
  Postleitzahlen := TCustomObjectList<TPostleitzahlen>.Create;

  Test(ZahlungsartList.AsNonGeneric);
  Test(Postleitzahlen.AsNonGeneric);
end.

[RWarnecke]

Zitat:

Zitat von Uwe Raabe (Beitrag 1189073)

Als globale Prozedur wird das nicht gehen, lediglich als Methode eines Records oder einer Klasse:

Delphi-Quellcode:

  TDummy = record
    class procedure Test<T:class>(ObjectList: TCustomObjectList<T>); static;
  end;


  TDummy.Test<TZahlungsart>(ZahlungsartList);
  TDummy.Test<TPostleitzahlen>(Postleitzahlen);

Kann ich die Test-Procedure auch überladen ? Wenn ja, wie geht das ? Wo kann ich das nachlesen ?

[himitsu]

Was willst du denn überladen?

Aber ja, "overload" funktioniert wie mit jeder normalen Methode auch.


PS: Man kann sich auch aussuchen wo man den generischen Typen deklariert.

Delphi-Quellcode:

  TDummy = record // oder class macht keinen großen Unterschied
    class procedure Test<T:class>(ObjectList: TCustomObjectList<T>); static;
  end;

  TDummy.Test<TZahlungsart>(ZahlungsartList);
  TDummy.Test<TPostleitzahlen>(Postleitzahlen);

  TDummy<T:class> = record // oder class macht keinen großen Unterschied
    class procedure Test(ObjectList: TCustomObjectList<T>); static;
  end;

  TDummy<TZahlungsart>.Test(ZahlungsartList);
  TDummy<TPostleitzahlen>.Test(Postleitzahlen);

Letzeres hat einen Vorteil, wenn man eine Funktion mit einem bestimmten Typen oft aufruft.
Ersteres, wenn man viele Verschiedene Typen nutzt.
Und es läßt sich beliebig kombinieren.

Delphi-Quellcode:

type ZahlDummy = TDummy<TZahlungsart>;

ZahlDummy.Test(ZahlungsartList);

[RWarnecke]

Zitat:

Zitat von himitsu (Beitrag 1193925)

Was willst du denn überladen?

Wenn ich inder Procedure noch einen weiteren Parameter einfüge und den zum Beispiel einmal als String und einmal als Integer haben möchte. Beispiel :

Delphi-Quellcode:

  TDummy = record
    class procedure Test<T:class>(ObjectList: TCustomObjectList<T>; ID: Integer); static;
    class procedure Test<T:class>(ObjectList: TCustomObjectList<T>; ID: string); static;
  end;


  TDummy.Test<TZahlungsart>(ZahlungsartList, 1);
  TDummy.Test<TZahlungsart>(ZahlungsartList, '1');

So wie ich es im Beispiel angegeben habe, funktioniert es nicht mit static oder overload. Dieses soll nur ein Beispiel sein um das Überladen zu verstehen.