Container-Klassen in Delphi

[OregonGhost]

Du benötigst auch beim Rückgabewert keinen vollqualifizierten Typnamen, wenn der entsprechende Namespace oder Typ importiert wurde, was wohl der Fall ist, wenn du List<T> ohne Namespace-Angabe verwendest.

[Elvis]

Zitat von Luckie:

Zitat von Khabarakh:

ebenso die Namespace-Angabe von IEnumerator<T>, die eher verwirren dürfte und die du bei List<T> ja auch nicht verwendet hast.

Aber die brauche ich doch für das foreach Konstrukt:

Dafür solltest du IEnumerable<T> implementieren.
Denn so wie du es jetzt hast, hast du nur eine öffentliche Methode GetEnumerator und vertraust darauf, dass der Compiler anhand dieses Namens und des Rückgabewertes entscheidungen trifft. Aber ohne IEnumerable<T> gibt es kein LINQ und viele andere Dinge gehen auch nicht.
Eine Containerklasse sollte in .net alle Standardinterfaces implementieren, die auf sie zutreffen.
Bei dir wäre das IList<T>, welches ICollection<T> und IEnumerable<T> mitbringt.

[Luckie]

Zitat von Elvis:

Dafür solltest du IEnumerable<T> implementieren.
Denn so wie du es jetzt hast, hast du nur eine öffentliche Methode GetEnumerator und vertraust darauf, dass der Compiler anhand dieses Namens und des Rückgabewertes entscheidungen trifft. Aber ohne IEnumerable<T> gibt es kein LINQ und viele andere Dinge gehen auch nicht.
Eine Containerklasse sollte in .net alle Standardinterfaces implementieren, die auf sie zutreffen.
Bei dir wäre das IList<T>, welches ICollection<T> und IEnumerable<T> mitbringt.

Da stehe ich jetzt ehrlich gesagt etwas auf dem Schlauch.

[Elvis]

Zitat von Luckie:

Da stehe ich jetzt ehrlich gesagt etwas auf dem Schlauch.

IEnumerable ist das Basisinterface für alles worüber man einen for-each machen kann.
Also für alle Datencontainer.
IEnumerable<T> ist eine Spezialisierung für einen bestimmten Itemtypen.
"LINQ over Objects" basiert auf IEnumerable<T>, genau wie viele Methoden von vielen Hunderten von Klassen mit IEnumerable<T> umgehen können.
Es nicht zu implemetnieren würde heißen, dass deine Containerklasse nur so wie in Delphi wäre: Eine weitere Klasse. Mit der Implementierung ist sie eine richtige Containerklasse, auf die du Abfragen machen kannst, die du mit einem Call an eine andere Liste anhängen kannst,...

Mit meinem Beispiel oben wäre folgende LINQ-Query möglich:

Delphi-Quellcode:

var persons := new PersonList<Person>();
// irgendws hinzufügen

var personNames := 
  (from   p in persons
   where  not String.IsNullOrEmpty(p.Name)
   select distinct p.Name).ToList();

[Luckie]

Ich habe jetzt eine aktualisierte Fassung im ersten Posting hochgeladen. Die Modifikationen der Klasse, wie sie Elvis vorschlägt sind noch nicht eingearbeitet.

[xZise]

Zitat von Khabarakh:

Zitat von xZise:

Warum nicht von TList erben, und dann die Add... Methoden mit neuen Parametern überschreiben?

Wie willst du eine statische Methode überschreiben, noch dazu mit anderen Parametern ? Und wenn du Add nur verdeckst/überlädst, hast du am Ende alles Mögliche, aber auf keinen Fall eine typsichere Liste.

*pfeif*

Ich sehe gerade, Luckie, dass du fast genauso wie ich es vorgeschlagen habe, hast du es umgesetzt.

MfG
xZise

[mashutu]

Sorry wenn das jetzt hier leicht OT wird,
aber ich bin soeben ueber den Konstrukt

Delphi-Quellcode:

type  
  PersonList<T> = public class(IList<T>)
    where T is Person, T has constructor;
[...]

gestolpert.
Ich arbeite zwar seit mehr als 20 Jahren mit Pascal, aber diese Syntax ist mir neu und latuernich moechte ich wissen, was das ist und wie man es verwenden kann. Falls jemand einen Link zu einem Tutorial hat, waere ich dankbar.

[Luckie]

Das ist ja auch kein Pascal, sondern C#.

[Khabarakh]

Nope, das ist Roberts Chrome-Schnipsel .

@mashutu: Chrome ist ein Pascal-Dialekt für .Net. Was du dort siehst, ist ein .Net-Feature namens Generics, die vor allem von Java bekannt sind. Auch FreePascal, C++, Ada, ... bieten so etwas (Ähnliches).
Kurz umrissen kannst du beim Benutzen der Klasse den Typparameter T durch einen beliebigen Typ ersetzen (wobei da noch die Constraints eine Rolle spielen, die du mitgequotet hast: T muss von Person abgeleitet sein und einen öffentlichen, parameterlosen Konstruktor haben).

Delphi-Quellcode:

var
  list : PersonList<Customer>; // T = Customer (eine von Person abgeleitete Klasse)
begin
  [...]
  list[0].Orders[...]; // Person besitzt keine Eigenschaft Orders, dennoch müssen wir nicht casten, da Item[] ja nicht Person sondern T zurückgibt. Und in unserem Fall ist T = Customer
end;

[mashutu]

Danke an Lucky und Khabarakh fuer die kurze Info und den Link zu Chrome