Code Optimierung gesucht

[Martin W]

Zitat:

Zitat von mkinzler (Beitrag 1285288)

Vielleicht ist es möglich statt x Listen einen Array/Directory der Listen zu verwenden, dann kannst Du den Code einfach zusammenfassen.

Danke für die Idee, werde mir das mal näher anschauen.

[Bjoerk]

Wenn Autohersteller eine so wichtige Eigenschaft ist könnte man überlegen die nach TAuto zu packen? Und ich würde auf jeden Fall auch nur eine Liste nehmen.

[Martin W]

Zitat:

Zitat von Bjoerk (Beitrag 1285290)

Wenn Autohersteller eine so wichtige Eigenschaft ist könnte man überlegen die nach TAuto zu packen? Und ich würde auf jeden Fall auch nur eine Liste nehmen.

Ja, ich bin gerade am prüfen, wären fast 25000 Zeilen Code die ich prüfen & nachziehen müsste.

[mkinzler]

Würde ich auch. Ihm scheinen aber die getrennten Listen wichtig zu sein.

[Martin W]

Zitat:

Zitat von mkinzler (Beitrag 1285292)

Würde ich auch. Ihm scheinen aber die getrennten Listen wichtig zu sein.

Ja, darauf wird es wohl hinauslaufen! Danke für eure Antworten.

[Martin W]

OK, angenommen ich habe eine gesamte Liste

Delphi-Quellcode:

AutoListe: TList<TAuto>

.

Gibt es eine effizente Möglichkeit, zum Beispiel alle Items anzeigen zu lassen, die vom Typ TAutoHerstellerA (

Delphi-Quellcode:

AutoListe[n] is TAutoHerstellerA

) sind?

[glotzer]

An sich spricht doch auch nix dagegen dass ein Auto in mehreren Listen gleichzeitig ist oder? Du kannst ja deine einzelnen Listen beibehalten und eben zusätzlich noch eine große gemeinsame Liste führen.

[Martin W]

Zitat:

Zitat von glotzer (Beitrag 1285295)

An sich spricht doch auch nix dagegen dass ein Auto in mehreren Listen gleichzeitig ist oder? Du kannst ja deine einzelnen Listen beibehalten und eben zusätzlich noch eine große gemeinsame Liste führen.

Ja, hab es jetzt mit Properties gelöst. Beim Zugriff auf die Variable wird die Meta-Liste jeweils neu zusammmengebaut.

[Bjoerk]

Hast du die Idee von Markus mit dem Array probiert?

Delphi-Quellcode:

TAutoHersteller = (ahVW, ahMBW, ahBenz)

TAutoList = class(TObjectList)

TAutos = array[TAutoHersteller] of TAutoList;

for AutoHersteller := Low(TAutoHersteller) to High(TAutoHersteller) do
 for I := 0 to FAutos[AutoHersteller].Count - 1 do
   if FAutos[AutoHersteller].Items[I].NameOfCar = aCar then

[Dejan Vu]

Also ich würde wirklich einen einzigen Container für alle Autos verwenden. Falls nur über Autos eines bestimmten Typen iteriert werden soll, dann spendiert man dem Container eine Methode/Funktion, mit der man durch alle Autos eines bestimmten Typen iterieren kann.

Delphi-Quellcode:

Type
  myCarContainer : TCarContainer;

Begin
  myCarContainer := TCarContainer.Create;
  myCarContainer.Add(THerstellerA.Create);
  ...
  ...

Var
  myIterator : TCarIterator<THerstellerA>;
  allIterator : TCArIterator<TAuto>;
begin
  myIterator := myCarContainer.GetCars<THerstellerA>;
  while myIterator.Next do
    DoSomethingWith (myIterator.Current);
  ...
  allIterator := myCarContainer.GetCars<TAuto>;
  while allIterator.Next do
    myIterator.Current.Color := NeueFarbe;
  ...

Man könnte sich vom Container auch gleich die ganze Liste geben lassen, aber dann hätte man die Instanzen redundant gespeichert, was unnötig ist.

Natürlich soll man den bestehenden Code nicht umschreiben, es kann also wirklich sinnvoll sein, die Listen aus dem Container zu extrahieren, um die betreffenden Codestellen nicht zu sehr umschreiben zu müssen. Allerdings glaube ich, das man hier mit Refaktoring sehr viel vereinfachen kann, denn irgendwie scheinen die ganzen Listen doch eh nur immer wieder durchlaufen zu werden. Und das geht auch sehr elegant mit einer ForEach-Methode:

Delphi-Quellcode:

...
myCarContainer.ForEach<THerstellerA>(ChangeColor);
...

Function ChangeColor (item : THerstellerA) : Boolean;
Begin
  item.Color := ColorToChange;
  Result := True; // False würde den 'ForEach' Operator abbrechen
End;

Das kann man noch beliebig weiterspinnen. Wichtig ist hier, das man zuerst die Funktionalität definiert, d.h. das Interface und das dann implementiert. Und das Interface richtet sich eben u.a. daran, möglichst wenig am Code kaputt zu optimieren.