TObjectList sauber an function übergeben und wieder zurück

[norwegen60]

Hallo.

ich habe eine TObjectList, bei der ich verschiedene Berechnungen vornehmen will. Ich suche den sauberen Weg, wie ich die Liste an die Funktionen übergeben und des Ergebnis wieder zurück gebe. Dabei soll es möglich sein, dass die SourceList unverändert bleibt.

Hier ein abgespecktes Beispiel

Delphi-Quellcode:

type
  TTest = class
  private
    FValue: Double;
  public
    property Value: Double read FValue write FValue;

    constructor Create;
    destructor Destroy; override;
  end;

  TTestList = class(TObjectList<TTest>);

implementation

procedure PrePareList(SourceList, DestList: TTestList);
// Erstellt Liste und kopiert Werte von SourceList dort hin
var
  i: Integer;
  lTest: TTest;

begin
  if DestList <> nil then
    DestList.Free;
  DestList := TTestList.Create(true);

  for i := 0 to SourceList.Count - 1 do
  begin
    lTest := TTest.Create;
    DestList.Add(lTest);
    lTest.Value := SourceList[i].Value;
  end;
end;

function DoAdding(SourceList, DestList: TTestList):Boolean;
var
  i: Integer;
  lTempList: TTestList;

begin
  PrePareList(SourceList, DestList: TTestList); // Damit wird in jedem Fall DestList = SourceList zurück gegeben

  for i := 0 to DestList.Count - 1 do
    DestList[i].Value := DestList[i].Value + 5;

  Result := true;  // Wenn korrekt ausgeführt. In Beispiel einfach immer
end;

function DoMultiplicate(SourceList, DestList: TTestList):Boolean;
var
  i: Integer;
  lTempList: TTestList;

begin
  PrePareList(SourceList, DestList: TTestList); // Damit wird in jedem Fall DestList = SourceList zurück gegeben

  for i := 0 to DestList.Count - 1 do
    DestList[i].Value := DestList[i].Value * 5;

  Result := true;  // Wenn korrekt ausgeführt. In Beispiel einfach immer
end;

procedure DoCalculations(SourceList, DestList: TTestList);
var
  lTempList: TTestList;

begin
  PrePareList(SourceList, DestList: TTestList); // Damit wird in jedem Fall DestList = SourceList zurück gegeben

  if FlagAddieren then
  begin
    if DoAdding(DestList, lTempList: TTestList) then
    begin
      DestList.Free;
      DestList := lTempList;
      lTempList := nil;
    end;
  end;

  if FlagMultiplicate then
  begin
    if DoMultiplicate(DestList, lTempList: TTestList) then
    begin
      DestList.Free;
      DestList := lTempList;
      lTempList := nil;
    end;
    // Bei false wären Daten ja immer noch unverändert in DestList. Abder ein mögliches Speicherleck
  end;
end;

procedure Start;
var
  i: Integer;
  lStartList, lResultList: TTestList;
  lTest: TTest;

begin
  lStartList := TTestList.Create(true);
  try
    for i := 1 to 5 do
    begin
      lTest := TTest.Create;
      lStartList.Add(lTest);
      lTest.Value := i;
    end;

    DoCalculations(lStartList, lResultList: TTestList);

  finally
    lStartList.Free;
    lResultList.Free;
  end;
end;

So das Prinzip.

Jetzt aber die Fragen:

• Wie mache ich das sauber, so dass der Speicher sauber created und wieder gefreet wird
• Der Rechenablauf minimiert wird
• Wann ist bei der Übergabe an die procdure/function var nötig/sinnvoll procedure DoCalculations(var SourceList, DestList: TTestList);
• Welche Vorteile böten sich bei lTempList := DoAdding(DestList) . Wo findet hier sinnvollerweise das lTempList := TTestList.Create statt. In der function oder vor dem Aufruf