Wie kann ich feststellen, ob Sub-Klasse schon gelöscht ist

[norwegen60]

Hallo zusammen

ich habe vereinfacht folgende Klassen struktur:

Delphi-Quellcode:

Tvalues:Class
  x:Double;
  y:Double;
end;

TTest:Class
  Name:String;
  Values:TValues;
end;

TTestListList = class(TObjectList<TTest>)

Es kann es sein, dass mehrere TTest auf das gleich TValues zeigen

Jetzt will ich in allen TTest, denen ein TValues zugewiesen ist, dieses löschen

Delphi-Quellcode:

for i := 0 to TestList.Count do
  if (TestList[i].Values <> nil) then
    TestList[i].Values.Free;

Da Free Values nicht auf nil setzt, schlägt die Prüfung gegen nil beim nächsten TTest mit demselben TValues fehl und Delphi hängt sich beim nochmaligen Value.Free auf.
Einfach TestList[i].Values := nil; ist auch keine gute Lösung, da ich dann lauter Leichen rum liegen habe
Mir alle TValues merken und sie, nachdem ich alle TestList[i].Values := nil gesetzt habe, scheint mir aufwändig

Wie aber kann ich TValues löschen (Free) und dann auch merken, dass der bereits gelöscht wurde.

Danke
Gerd

[DeddyH]

Das ist eben das Problem bei Mehrfachreferenzen. Entweder man stellt komplett auf Interfaces um oder ernennt eine "Masterliste", welche dann Owner der enthaltenen Objekte ist. Weitere Listen werden dann mit OwnsObjects auf false erzeugt, damit es nicht knallt, wenn diese wieder freigegeben werden.

[norwegen60]

Mmh, Mist. Und ich hatte gehofft, dass es einen Weg gibt umd festzustellen, dass ein Object gefreet wurde.

In Ermanglung von Interface-Wissen würde ich es so machen:

Delphi-Quellcode:

ValueList := TValueList.Create(True);
try
  for i := 0 to TestList.Count do
    if (TestList[i].Values <> nil) then
    begin
      bExist:=False;
      for j:=0 to ValueList.Count-1 do
      begin
        // Hier bin ich mir nicht ganz sicher, ob ich es mir so einfach machen kann.
        // Ich habe es schon mal so gemacht und es hat funktioniert. Aber ist es sicher?
        if (ValueList[j] = TestList[i].Values) then  
          bExits:= True;
        if bExist then 
          break;
      end;
      
      if not bExist then
        ValueList.Add(TestList[i].Values);

      TestList[i].Values := Nil;
  end;
finally
  ValueList.Free;
end;

Oder geht es einfacher

[Edelfix]

Delphi-Quellcode:

for i := 0 to TestList.Count do
  if (TestList[i].Values <> nil) then
    FreeAndNil(TestList[i].Values);

[norwegen60]

Zitat von Edelfix:

[DELPHI]
for i := 0 to TestList.Count do
if (TestList[i].Values <> nil) then
FreeAndNil(TestList[i].Values);

Das habe ich als erstes probiert. Das lässt Delphi nicht zu

Code:

[DCC Fehler] uQualHelper.pas(187): E2197 Konstantenobjekt kann nicht als Var-Parameter weitergegeben werden

[jziersch]

Zitat:

Es kann es sein, dass mehrere TTest auf das gleich TValues zeigen

In diesem Fall würde ich eine separate Liste anlegen in denen die TValues + eine eindeutige ID (Cardinal) gespeichert werden. In deiner TTest Klasse hast Du dann nur diese ID.
Jede neues TValue erzeugt eine neue ID mit Inc(LastID).
Wenn Du ein TValue löscht werden die IDs automatisch ungültig. Dies Liste ist sortiert, da neue Values hinten angehängt werden. Wert-Lücken ergeben sich durch das löschen.

Du kannst das TValue zu jeder ID schnell mit List.BinarySearch suchen - und wenn es nicht gefunden wird, ist der Wert eben ungültig.

Anmerkung - müsste es nicht heißen for i:=0 to List-Count-1 do ?

[Lemmy]

Servus,

Zitat von norwegen60:

Es kann es sein, dass mehrere TTest auf das gleich TValues zeigen

Jetzt will ich in allen TTest, denen ein TValues zugewiesen ist, dieses löschen

d.h. TTEst legt die Instanz von TValues nicht an, sondern bekommt die zugewiesen oder holt die sich wo her. Bisher hat sich bei mir folgendes bewährt:
Wer Objekte anlegt, der gibt die auch wieder frei (keine Regel ohne Ausnahme). D.h. du kannst so vorgehen wie jziersch vorschlägt. Oder du sagst etwas mehr darüber wie die KLassen zueinander finden.

ein FreeAndNil funktioniert nicht, weil die Funktion eben einen Var-Parameter braucht. Lösen kannst Du das mit einem Zweizeiler:

Delphi-Quellcode:

for i := 0 to TestList.Count do
  if (TestList[i].Values <> nil) then
  begin
    TestList[i].Values.Free;
    TestList[i].Values := nil;
  end

allerdings klappt das im weiteren Verlauf nicht weil:

Zitat von norwegen60:

Es kann es sein, dass mehrere TTest auf das gleich TValues zeigen

Daher bleibt imho nix anderes als eine zentrale Liste / Klasse, die die Lebensdauer von TValues überwacht, erstellt, freigibt. Wenn Du zum drum herum noch das eine oder andere sagen kannst, dann kann man hier vielleicht auch noch den einen oder anderen Tipp geben.

Grüße

[Uwe Raabe]

Eine ziemlich bequeme Möglichkeit wäre es, die Klassen von TComponent abzuleiten und mit FreeNotification zu arbeiten. Das könnte dann in etwa so aussehen:

Delphi-Quellcode:

type
  TValues = class(TComponent)
  public
    x: Double;
    y: Double;
  end;

  TTest = class(TComponent)
  public
    Name: String;
  private
    FValues: TValues;
    procedure SetValues(const Value: TValues);
  protected
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  public
    property Values: TValues read FValues write SetValues;
  end;

procedure TTest.Notification(AComponent: TComponent; Operation: TOperation);
begin
  if (AComponent = FValues) and (Operation = opRemove) then
    FValues := nil;
  inherited;
end;

procedure TTest.SetValues(const Value: TValues);
begin
  if FValues <> Value then
  begin
    if FValues <> nil then
      FValues.RemoveFreeNotification(Self);
    FValues := Value;
    if FValues <> nil then
      FValues.FreeNotification(Self);
  end;
end;

Die verbleibenden public Fields würde ich aber gleich auch noch in Properties umwandeln.

[mytbo]

Zitat von norwegen60:

Wie aber kann ich TValues löschen (Free) und dann auch merken, dass der bereits gelöscht wurde.

Eine weitere Möglichkeit ist, das Values-Objekt mit einer Referenzzählung auszustatten:

Delphi-Quellcode:

type
  TValues = class(TObject)
  strict private
    FRefCount: Integer;
  private
    FX: Double;
    FY: Double;
  public
    constructor Create(pmX, pmY: Double); reintroduce;
    procedure IncReference;
    procedure DecReference;
    property X: Double
      read FX;
    property Y: Double
      read FY;
  end;

  TTest = class(TObject)
  private
    FName: String;
    FValues: TValues;
    procedure FreeValues;
    procedure SetValues(pmValues: TValues);
  public
    constructor Create(const pmcName: String); reintroduce;
    destructor Destroy; override;
    property Name: String
      read FName;
    property Values: TValues
      read FValues write SetValues;
  end;

  TTestList = class(TObjectList<TTest>)
  public
    procedure FreeAllValues;
  end;
  
constructor TValues.Create(pmX, pmY: Double);
begin
  inherited Create;
  FX := pmX;
  FY := pmY;
end;

procedure TValues.IncReference;
begin
  Inc(FRefCount);
end;

procedure TValues.DecReference;
begin
  Dec(FRefCount);
  if FRefCount = 0 then
    Self.Free;
end;

constructor TTest.Create(const pmcName: String);
begin
  inherited Create;
  FName := pmcName;
end;

destructor TTest.Destroy;
begin
  FreeValues;
  inherited Destroy;
end;

procedure TTest.FreeValues;
begin
  if FValues <> Nil then
  begin
    var v: TValues := FValues;
    FValues := Nil;
    v.DecReference;
  end;
end;

procedure TTest.SetValues(pmValues: TValues);
begin
  FreeValues;
  if pmValues <> Nil then
  begin
    pmValues.IncReference;
    FValues := pmValues;
  end;
end;

procedure TTestList.FreeAllValues;
begin
  for var i: Integer := 0 to Count - 1 do
    Items[i].Values := Nil;
end;

var
  v: TValues;
  t: TTest;
begin
  v := TValues.Create(1, 2);
  t := TTest.Create('A');
  t.Values := v;
  FList.Add(t);
  t := TTest.Create('B');
  t.Values := v;
  FList.Add(t);
  FList.FreeAllValues;

Bis bald...
Thomas

[Uwe Raabe]

Zitat von mytbo:

Eine weitere Möglichkeit ist, das Values-Objekt mit einer Referenzzählung auszustatten

Würde das nicht lediglich verhindern, dass die TValues Instanz vorab freigegeben wird? Damit umgeht man das Problem zwar (in dem gezeigten Beispiel durchaus valide), löst es aber nicht wirklich.