Code Optimierung gesucht

[Martin W]

Hi,

ich habe folgende Klassen (alles stark vereinfacht und auf das grundlegende Problem reduziert):

Delphi-Quellcode:

type TAuto = class(TComponent)
public
  FNameOfCar: string;
  FColor: integer;
  FNumberOfWheels: integer;
  FLicencePlate: string;
end;

type TAutoHerstellerA = class(TAuto)
public
  FWindowColor: integer;
  FNumberOfDoors: integer;
end;

type TAutoHerstellerB = class(TAuto)
public
  FHupe: boolean;
end;

type TAutoHerstellerC = class(TAuto)
public
  FNiceCar: boolean;
end;

type TAutoHerstellerD = class(TAuto)
public
  FRamboPackage: boolean;
  FAutonomCar: boolean;
end;

Verwaltet werden die Auto-Hersteller A-D in folgenden Klassen:

Delphi-Quellcode:

FAutoHerstellerA: TList<TAutoHerstellerA>;
FAutoHerstellerB: TList<TAutoHerstellerB>;
FAutoHerstellerC: TList<TAutoHerstellerC>;
FAutoHerstellerD: TList<TAutoHerstellerD>;

Nun der interessante Code, ich möchte ein bestimmtes Auto umfärben, jedes Auto existiert nur einmal:

Delphi-Quellcode:

procedure ColorCar(aCar: string, aNewColor: integer);
var
  i: integer;
begin

  for i:=0 to FAutoHerstellerA.Count -1 do
    begin
      if FAutoHerstellerA[i].FNameOfCar = aCar then
        FAutoHerstellerA[i].FColor := aNewColor;
      Break;
    end;

  for i:=0 to FAutoHerstellerB.Count -1 do
    begin
      if FAutoHerstellerB[i].FNameOfCar = aCar then
        FAutoHerstellerB[i].FColor := aNewColor;
      Break;
    end;

  for i:=0 to FAutoHerstellerC.Count -1 do
    begin
      if FAutoHerstellerC[i].FNameOfCar = aCar then
        FAutoHerstellerC[i].FColor := aNewColor;
      Break;
    end;

  for i:=0 to FAutoHerstellerD.Count -1 do
    begin
      if FAutoHerstellerD[i].FNameOfCar = aCar then
        FAutoHerstellerD[i].FColor := aNewColor;
      Break;
    end;

end;

Man sieht schon, je nach Anzahl der Autohersteller habe ich viele Wiederholungen. Gibt es daher die Möglichkeit, die Listen zu einer Art Gruppe zusammenzufassen und die Gruppe zu durchsuchen?

Viele Grüße,
Martin

[mkinzler]

Sind die Klassen wirklich so verschieden, dass man das nicht durch Eigenschaften/Vererbung/Interfaces lösen könnte?

[Martin W]

Die Grundklasse "TAuto" ist überall gleich, der Rest leider nicht. In der Funktion wird nur auf Eigenschaften von TAuto zurückgegriffen. Habe gerade folgende Idee bekommen:

Delphi-Quellcode:

var
  WorkingList: TList<TAuto>;
begin

  WorkingList Create

  WorkingList.Add(alle anderen Listen hinzufügen zur List)

  Kombinierte Liste durchsuchen

  WorkingList wieder freigeben

end;

[Dejan Vu]

Pack doch einfach alle Autos in eine einzige Liste.

[Martin W]

Zitat:

Zitat von Dejan Vu (Beitrag 1285279)

Pack doch einfach alle Autos in eine einzige Liste.

Ja, das hab ich gemacht, wie folgt:

Delphi-Quellcode:

var
  WorkingList: TList<TAuto>;
begin

  WorkingList := WorkingList<TAuto>.Create;

  WorkingList.AddRange(TAutoHerstellerA);
  WorkingList.AddRange(TAutoHerstellerB);
  WorkingList.AddRange(TAutoHerstellerC);
  WorkingList.AddRange(TAutoHerstellerD);

  for i:=0 to WorkingList.Count -1 do
    begin
      if WorkingList[i].FNameOfCar = aCar then
        WorkingList[i].FColor := aNewColor;
      Break;
    end;

  WorkingList.Free;

end;

Nachteil: Die Liste muss vor jeder Nutzung neu erstellt ("kombiniert") werden. Gibt es eine Möglichkeit, die Liste dynamisch zu halten, so dass bei Änderung von TAutoHerstellerA automatisch die WorkingList mit aktualisiert wird? Ok, eine Idee für das wären Properties.

[mkinzler]

Nicht nur zum Suchen, sondern grundsätzlich eine Liste.

[Martin W]

Zitat:

Zitat von mkinzler (Beitrag 1285283)

Nicht nur zum Suchen, sondern grundsätzlich eine Liste.

Die werden ziemlich häufig individuell verarbeitet, nur selten gemeinsam. Daher ist der dadurch entstehende Aufwand höher, als wenn ich sie auseinander lasse.

AddRange klappt im oberen Code nicht, gibt es eine andere Möglichkeit, die Listen zu kombinieren?

[mkinzler]

Durch das Kominieren nur zu diesem Zweck gewinnst Du nichts im Vergleich zur separaten Suche in den getrennten Listen.

[Martin W]

Zitat:

Zitat von mkinzler (Beitrag 1285286)

Durch das Kominieren nur zu diesem Zweck gewinnst Du nichts im Vergleich zur separaten Suche in den getrennten Listen.

Performancetechnisch nichts, aber codemäßig, vor allem wen das nicht 4 Listen sind, sondern 50.

[mkinzler]

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