Eine Generics TObjectList<T> als Parameter

[RWarnecke]

Hallo zusammen,

ich habe eine generics ObjectList so definiert TCustomObjectList<T: class> = class(TObjectList<T>) und als Variable so definiert ZahlungsartList : TCustomObjectList<TZahlungsart>; . Das funktioniert auch wunderbar. Ich kann ja die Generic-ObjectList so wie ich Sie als Variable deklariert habe übergeben : 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 von 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);

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 von himitsu:

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.