Hallo Freunde,

heute mal was für Generic-Anfänger, wie ich es bin. Bisher hab ich die Dinger immer nur benutzt - das soll sich nun ändern.

Ich habe immer wieder das Problem, das ich Objekte en masse in ObjectLists speichern und immer wieder das eine oder andere Objekt in dieser Liste suchen muß. Generics waren eine - wenn auch sehr codeaufblähende - prima Lösung. Nur das Gesuche ist noch immer "doof".

Ich habe nun vor, mich dem Problem schrittweise zu nähern. Meine erste Idee:

markieren

Delphi-Quellcode:

type
   TMyObjectList<T> = class(TObjectList<T>);

Das funktioniert offenbar, weil es ohne Error compiliert Okay.

zusammenfalten · markieren

Delphi-Quellcode:

type
   TMyObjectList<T> = class(TObjectList<T>);
   public
      function Search(ASearchCrit: integer): T;
   end;
[...]
function TMyObjectList<T>.Search(ASearchCrit: integer): T;
begin
   for Result in Self do
   begin
      if Result. //<--- Äh... Das funktioniert nicht. Gar nicht
   end;
end;

Wie man sieht, ist mein Ansatz eine direkte Fahrt gegen die Wand. Zwei Fragen:

1. Wie löst man sowas ?
2. Da in TMyObjectList irgendwas gestopft werden kann - bin ich gezwungen, alle möglichen Typen zuerst abzutesten oder gibt es da auch eine clever Lösung ?

markieren

Delphi-Quellcode:

Result:=true;
if T is TDriver then exit;
if T is TSpecialDriver then exit;
if T is TExtraSpecialDriver then exit;
Result:=false;

Thanks für die Schubser,

Olaf

Haben die Typen eine gemeinsamen Vorfahren? Soll einer davon ausgeschlossen werden? Wenn Ja, kannst du die Anweisungen zusammenfassen:
if T in [ TDriver, TSpecialDriver, TExtraSpecialDriver, ...] then Result := True else Result := False; Wenn es für alle Nachfahren einer Klasse gelten soll prüfe gegen diese.

Ah, eine gute Idee !

Die Klassen haben einen gemeinsamen Vorfahren und es reicht, gegen den zu testen:
Result:=(T is TDriverBase); Damit sind alle Nachfahren erfaßt und zulässig, alle anderen Klassen wie z.B. TComponent oder TWorkTime (völlig andere Unit) eliminiert.

Bleibt Problem 1.

Warum erzeugst du dann nicht eine typisierte generische Objektliste?

markieren

Delphi-Quellcode:

  TMyObjectList<T> = class(System.Generics.Collections.TObjectList<TDriverBase>)
   public
      function Search(ASearchCrit: integer): T;
   end;

Problem 1 versteht ich nicht. Was willst Du machen?

markieren

Delphi-Quellcode:

type
  TMyObjectList<T> = class(TObjectList<T>);
  public
    function Search(const predicate: TPredicate<T>): T;
  end;

Einsatz:

markieren

Delphi-Quellcode:

myDriver := driverList.Search(
  function(d: TDriver): Boolean
  begin
    Result := d.Id = 1234
  end);

Vorteil: Du schränkst deine generische Listenklasse nicht auf bestimmte Suchkriterien ein, die nur für bestimmte Arten von T gelten.

Wenn dir das Schreiben der anonymen Methode zu unhandlich ist, kannst du das auch noch auslagern:

markieren

Delphi-Quellcode:

function DriverById(i: Integer): TPredicate<TDriver>;
begin
  Result :=
    function(d: TDriver): Boolean
    begin
      Result := d.Id = i;
    end;
end;

Einsatz:

markieren

Delphi-Quellcode:

myDriver := driverList.Search(DriverById(1234));

Eventuell kannst du dir auch Spring4D anschauen, die Listen dort unterstützen alle Arten von Suchen, Filtern, etc

Er will ja aber nur Nachfahren einer bestimmte Klasse aufnehmen, deshalb erschien mir die Einschränkung sinnvoll.

Zitat von mkinzler:

Warum erzeugst du dann nicht eine typisierte generische Objektliste?

markieren

Delphi-Quellcode:

  TMyObjectList<T> = class(System.Generics.Collections.TObjectList<TDriverBase>)
   public
      function Search(ASearchCrit: integer): T;
   end;

Und wie bekommst du jetzt die Einschränkung hin? Denn das geht ja jetzt auch:

markieren

Delphi-Quellcode:

var
  List : TMyObjectList<Integer>;

Oder wolltest du eher so etwas schreiben:

markieren

Delphi-Quellcode:

  TMyObjectList<T:TDriverBase> = class(System.Generics.Collections.TObjectList<T>)
   public
      function Search(ASearchCrit: integer): T;
   end;

Allerdings ist die Variante von Stevie doch genau richtig. Die kann ich für alle Varianten benutzen. Und wenn ich eine Liste benötige, in der sich nur Elemente vom Typ TDriverBase und davon abgeleitete Klassen, dann

markieren

Delphi-Quellcode:

var
  List : TMyObjectList<TDriverBase>;

Wie praktisch, das einem der Kaffee ausgeht und man schnell mal losmuß, neuen zu besorgen. Sind ja tolle Ideen hier aufgeführt, danke schonmal dafür.

TMyObjectList<T:TDriverBase> = class(System.Generics.Collections.TObjectList<T>) ist eigentlich das, was mir vorschwebt. Dann sorgt doch schon der Compiler dafür, das ich da keinen Integer oder TWorkTime (der nichts mit TDriverBase zu tun hat) versuche einzufügen. Ain't I right ?

Die Datenmengen halten sich da in engen Grenzen, ein paar hundert Items, schlimmstenfalls. Da geht ein linear search allemal, wirds zu dolle, weiche ich dann schon von selbst auf ein binary search aus. Das Risiko ist aber gering. Mir geht es eigentlich darum, das ich immer wieder und wieder dieselben Routinen bastele:

zusammenfalten · markieren

Delphi-Quellcode:

//Suche Fahrer (Basisklasse)
function FindDriverByID(AID: integer): TDriverBase;
begin
   for Result in self do
      if Result.ID = AID then exit;
   Result:=nil;
end;

function FindDriverByName(AName: string): TDriverBase;
begin
...
end;

//Suche Fahrer (SpezialKlasse)
function FindSpecialDriverByID(AID: integer): TSpecialDriver;
begin
   for Result in self do
      if Result.ID = AID then exit;
   Result:=nil;
end;

function FindSpecialDriverByName(AName: string): TSpecialDriver;
begin
...
end;

//Suche Arbeitszeiten
function FindWorkTimeByID(AID: integer): TWorkTime;
begin
   //Benutzt natürlich eine andere Collection mit Worktimes drin
   for Result in self do
      if Result.ID = AID then exit;
   Result:=nil;
end;

function FindWorkTimeByDate(ADate: TDateTime): TWorkTime;
begin
   for Result in self do
      if Result.WorkDate = ADate then exit;
   Result:=nil;
end;

//und so weiter und so fort...

Ich suche nun einen Weg, sowas eben nur ein einziges Mal machen zu müssen und ich dachte, Generics sind ein idealer Weg dafür. Während der Fahrt nachgedacht bin ich dann auf folgende - beinahe ideale - Lösung gekommen: Da meine Fahrer alle ein paar Gemeinsamkeitein haben (eine eindeutige ID, Namen etc) und eigentlich nur über diese Felder gesucht wird, stopfen wir das in die TDriverBase-Klasse. Anschließend nehmen wir die oben genannte Deklaration und basteln die Suchroutinen - und schon kann ich prima Listen für meine verschiedenen Fahrertypen erzeugen, in die ich nix "unsinniges" stecken kann und doch ohne duplizierten Code suchen und ggf. noch andere lustige Dinge anstellen:

zusammenfalten · markieren

Delphi-Quellcode:

TMyObjectList<T:TDriverBase> = class(System.Generics.Collections.TObjectList<T>)
public
  function FindByID(AID: integer): T;
  function FindByName(AName: string): T;
end;

var
  TDriverList: TMyObjectList<TDriver>;
  TSpecialDriverList: TMyObjectList<TSpecialDriver>;
  //15 Bier später...
  TWorkTimeList: TMyObjectList<TWorkTime>; //funzt nicht, gibt sofort Haue vom Compiler

Damit bin ich einen gewaltigen Haufen Suchroutinen schon mal los. Genial, danke für den Schubser an euch alle.

Wenn Du die Arbeit nur einmal machen willst, dann mache doch eine Anleihe bei den .NET-Klassen, bzw. bei der Art, wie solche Dinge dort geregelt werden.

Wenn Du eine Searchable-List erzeugen willst, dann nimmst Du nur Mitgliederklassen an, die ein Interface "IComparable" implementieren. So kannst Du ohne Wissen um die konkrete Klasse die Objekte in Deiner Klasse sortieren. Hast Du Deine Liste in sortierter Form, dann ist auch eine binäre Suche leicht zu implementieren.

Soweit ich verstanden habe, wird die List sehr groß. Wenn sowas passiert und man will darin suchen ... normalerweise sortiert man das Ding. Ansonsten kannst du nur eine Lineare Suche machen (Kann ziemlich lange dauern).

Pseudo Lineare Suche:

markieren

Delphi-Quellcode:

for AnfangListe to EndeListe do
begin
  if Element=Gesucht then
  begin
    Result = ElementIndex // Oder was auch immer
    Break;
  end;
end;

Wird das Ding aber immer schön sortiert kannst du eine Binäre Suche machen. Diese ist wesentlich schneller als die Lineare Suche. Da es ne Liste ist, gibt es soweit ich weiß keine andern Suchmöglichkeiten mehr. Der Algorithmus ist ein wenig schwieriger, aber immernoch ziemlich einfach, wenn man es Rekursiv macht.

Gruß
Puke