Hallo zusammen,

ich möchte in einer TObjectList erkennen, wenn sich ein Object in der Liste geändert hat. Dazu habe ich folgendes (vereinfachtes) Konstrukt angedacht:

zusammenfalten · markieren

Delphi-Quellcode:

  // ***************************************************************************************************************************************
  // Die Basisliste mit dem Property Changed
  TBaseObjectList<T: class> = class(TObjectList<T>)
  private
    FChanged: Boolean;
  public
    constructor Create(AOwnsObjects: Boolean = True); overload;
    property Changed: TClass read FChanged write FChanged;
  end;

  // ***************************************************************************************************************************************
  // Die Basisklasse mit den zwei fixen Propteries
  TBase = class
  private
    FChanged: Boolean;
    FParentObject: TObject;
    procedure SetNr(Value: Integer);
    procedure SetChanged(const Value: Boolean);
  public
    property Changed: Boolean read FChanged write SetChanged;
    property ParentObject: TObject read FParentObject write FParentObject;

    constructor Create;
    destructor Destroy; override;
  end;

  // ***************************************************************************************************************************************
  // Als Beispiel eine auf ein eigenes Property abgespeckte Klasse
  TNamen = class(TBase)
  private
    FNamen: String;
    procedure SetNamen(const Value: String);
  public
    property Namen: String read FNamen write SetNamen;

    constructor Create;
    destructor Destroy; override;
  end;

  // ***************************************************************************************************************************************
  // Und die zu diesem Beispiel passende ObjectList
  TNamenList = TBaseObjectList<TNamen>;

Bei der Beschriftung der Eigenschaft Namen wird automatisch das Chanded-Property gesetzt

markieren

Delphi-Quellcode:

procedure TNamen.SetNamen(const Value: String);
begin
  if FNamen <> Value then
  begin
    FNamen := Value;
    Changed := True;
  end;
end;

Und jetzt soll über die Änderung des Changed-Property auch das Changed-Flag der entsprechenden Liste gesetzt werden. (Falls die Klasse einer Liste angehört), Dazu wurde dem Object bei der Erstellung die Liste als ParentObject mit gegeben

markieren

Delphi-Quellcode:

procedure TBase.SetChanged(const Value: Boolean);
begin
  if FChanged <> Value then
  begin
    FChanged := Value;
    if (FParentObject is TBaseObjectList) then // Prüfen, ob der Parent des Wertes eine TBaseObjectList ist Das geht so aber leider nicht
      TBaseObjectList(FParentObject).Changed := true; // Und wenn ja, die Liste auch auf Changed setzen
  end;
end;

Das Einlesen der Daten in die Liste würde so aussehen

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm15.btCreateListClick(Sender: TObject);
var
  i:Integer;
  lNamen:TNamen;
begin
  lNamenList := TNamenList.Create;
  for i:=0 to 5 do
  begin
    lNamen.Create;
    lNamenList.Add(lNamen);
    lNamen.ParentObject := lNamenList;
    lNamen.Namen := Format('Name%d', [i]);
    lNamen.Changed := False;
  end;
  lNamenList.Changed:=False;
end;

Jetzt stehen alle Werte und die Liste auf Changed = False

Und wenn ich so den Werte eines Eintrags ändere, steht dieser Wert auf Changed und es sollte auch die Liste auf Changed = True stehen

markieren

Delphi-Quellcode:

procedure TForm15.btChangeNameClick(Sender: TObject);
begin
  lNamenList[3].Namen := 'Neuer Name'; // Jetzt ist lNamenList[3].Changed = True und jetzt soll auch lNamenList.Changed = True sein
end;

Aktuell gehe ich bei jedem Save-Vorgang durch die verschiedenen Listen, aber es wäre eben resourcenschonender wenn ich gleich an der Liste selber sehen würde, ob ein Wert geändert wurde.

Gibte es eine Möglichkeit das zu realisiseren

Vielen Dank
Gerd

Zitat von norwegen60:

markieren

Delphi-Quellcode:

procedure TBase.SetChanged(const Value: Boolean);
begin
  if FChanged <> Value then
  begin
    FChanged := Value;
    if (FParentObject is TBaseObjectList) then // Prüfen, ob der Parent des Wertes eine TBaseObjectList ist
      TBaseObjectList(FParentObject).Changed := true; // Und wenn ja, die Liste auch auf Changed setzen
  end;
end;

Ist das korrekt? Müsste es nicht heißen:

markieren

Delphi-Quellcode:

procedure TBase.SetChanged(const Value: Boolean);
begin
  if FChanged <> Value then
  begin
    FChanged := Value;
    if Value and <FParentObject is TBaseObjectList) then // <<< Änderung hier
      TBaseObjectList(FParentObject).Changed := true;
  end;
end;

Also nur wenn der neue Wert True ist, auch Changed der Liste auf True setzen?

Kann sein, dass es in Deinem Anwendungsfall keinen Unterschied macht, kommt mir aber falsch vor.

Zitat von norwegen60:

Und wenn ich so den Werte eines Eintrags ändere, steht dieser Wert auf Changed und es sollte auch die Liste auf Changed = True stehen

So weit, so gut. Man kann anhand des Changed Flags der Liste erkennen, ob ein Eintrag in der Liste geändert wurde.

Mir ist nicht ganz klar, was Du damit meinst:

Zitat von norwegen60:

Aktuell gehe ich bei jedem Save-Vorgang durch die verschiedenen Listen, aber es wäre eben resourcenschonender wenn ich gleich an der Liste selber sehen würde, ob ein Wert geändert wurde.

Gibte es eine Möglichkeit das zu realisiseren

Suchst Du nach einer Möglichkeit, neben der reinen Information, dass mindestens ein Eintrag in einer Liste geändert wurde, auch zu sehen, welche Einträge geändert wurden, ohne die Liste durchgehen zu müssen?

Das ginge z.B., indem man zusätzlich noch eine ChangedObjects Liste mit Pointern auf die geänderten Objekte pflegt. Dann braucht man beim Speichern nur die ChangedObjects Liste durchgehen, die Objekte speichern und ChangedObjects löschen.

Folgendes ist dabei zu beachten:

• Beim Löschen eines Eintrag aus der Hauptliste muss dieser ggf. auch aus der ChangedObjects Liste gelöscht werden.
• Multithreading würde hier nochmal deutlich komplexer.

Es ginge noch mit etwas geringerem Speicherverbrauch ohne eine ChangedObjects Liste, indem man einen Changed Counter führt und dann beim Abspeichern der Liste die Einträge nur so lange durch geht, bis man genau diese Anzahl Änderungen gefunden und gespeichert hat. Das spart im Durchschnitt etwas Zeit. Wenn man Pech hat, wurde aber der letzet Eintrag geändert und man muss alle Einträge durchgehen, bis man den geänderten gefunden hat. Das kann man nochmal etwas optimieren, indem man den kleinste und den größten Index der geänderten Objekte pflegt, allerdings ist das ziemlich kompliziert, falls auch Einträge hinzugefügt und gelöscht werden, denn dann muessen jeweils auch diese beiden Indexe angepasst werden.

Zitat von dummzeuch:

Ist das korrekt? Müsste es nicht heißen:

markieren

Delphi-Quellcode:

procedure TBase.SetChanged(const Value: Boolean);
begin
  if FChanged <> Value then
  begin
    FChanged := Value;
    if Value and <FParentObject is TBaseObjectList) then // <<< Änderung hier
      TBaseObjectList(FParentObject).Changed := true;
  end;
end;

Ja, da hast du natürlich recht. Das Problem ist aber, dass Delphi die Typprüfung if (FParentObject is TBaseObjectList) then nicht akzeptiert. Genauso wenig wie die Zuweisung TBaseObjectList(FParentObject).Changed := true . Und da suche ich nach einer Möglichkeit, wie ich auf die BasisListe per TypeCast zugreifen kann.

Das mit dem Counter oder der zusätzlichen Liste sind Möglichkeiten, machen die Listenverwaltung aber nicht einfacher.
In meiner Anwendung gibt es 61 TObjectList und von der ein oder anderen noch mehrere Instanzen.

Versuch's mal so:

markieren

Delphi-Quellcode:

    if (FParentObject is TBaseObjectList<TBase>) then
      TBaseObjectList<TBase>(FParentObject).Changed := true;

Konsequenterweise sollte man die Liste auch so deklarieren: TBaseObjectList<T: TBase>

Vielen Dank
Mit den Änderungen lässt sich das Testprojekt jetzt compilieren. Aber zwei Dinge treten noch auf

• Die Abfrage (FParentObject is TBaseObjectList<TBase>) bringt kein TRUE zurück, obwohl ich lNamen.ParentObject := lNamenList; zugewiesen habe
• Spätestens wenn ich das Programm beende, kommt ein EAccessViolation auf. Kann aber auch schon passieren, wenn ich aus dem Programm in die IDE wechsle.

Ich bin nicht sicher, ob ich den Zusatz richtig verstanden habe

Zitat von Uwe Raabe:

Konsequenterweise sollte man die Liste auch so deklarieren: TBaseObjectList<T: TBase>

Ich habe es auf verschiedene Arten probiert, das Verhalten blieb aber immer gleich

markieren

Delphi-Quellcode:

  TBaseObjectList<T: class> = class(TObjectList<T>)
  TBaseObjectList<T: TBase> = class(TObjectList<T>)
  TBaseObjectList<TBase: class> = class(TObjectList<TBase>)