Generic ObjectList und Suchen - Wie am besten ?

[OlafSt]

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:

Delphi-Quellcode:

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

Das funktioniert offenbar, weil es ohne Error compiliert :D Okay.

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 ?

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

[mkinzler]

Haben die Typen eine gemeinsamen Vorfahren? Soll einer davon ausgeschlossen werden? Wenn Ja, kannst du die Anweisungen zusammenfassen:

Delphi-Quellcode:

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.

[OlafSt]

Ah, eine gute Idee !

Die Klassen haben einen gemeinsamen Vorfahren und es reicht, gegen den zu testen:

Delphi-Quellcode:

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.

[mjustin]

Ist ASearchCrit: Integer für alle zu unterstützenden Klassen in gleicher Weise die Suchbedingung?

Falls ja, könnte man entweder alle Klassen von einer ableiten die eine ID Property hat, und in der Schleife dann diese ID mit ASearchCrit vergleichen.

Alternativ könnte man ein Interface benutzen, das alle Klassen unterstützen und das diese ID Property definiert, auch dann kann ASearchCrit mit der ID verglichen werden.

Schliesslich gibt es noch die Möglichkeit Equals zu überschreiben. Doch das hat Risiken und Nebenwirkungen.

[mkinzler]

Warum erzeugst du dann nicht eine typisierte generische Objektliste?

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?

[Puke]

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:

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

[Stevie]

Delphi-Quellcode:

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

Einsatz:

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:

Delphi-Quellcode:

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

Einsatz:

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

[mkinzler]

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

[schöni]

Zitat:

Delphi-Quellcode:

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

Ab welcher Delphi Version funktioniert das?

[mkinzler]

Generics wurden in D2009 eingeführt