Weak-TList ?

[himitsu]

Tachchen.

Delphi-Quellcode:

var
  [Weak] Variable: IInterface;
  [Weak] Liste: TList<IInterface>;
  Liste: TList<[Weak] IInterface>;  // geht nicht - Error-Insight und Compiler sagen nein

Die Variable wäre jetzt ohne Referenzzählung, im NextGen-Compiler,
aber wie definiert man eigentlich eine Liste mit Weak-Referenzen?

Bei [Weak] Liste: TList<IInterface>; ist natürlich (nur?) die Liste-Variable ohne Referenzzählung, aber nicht der Listeninhalt. So würde ich die OH verstehen tun.

Kann es leider nicht ausprobieren und die Compiler sind diesbezüglich echt doof und geben keinerlei Meldungen/Fehlermeldungen, ob Attribute richtig sind oder ob sie es nicht sind.
Nichtmal bei Denen, die den Compiler und den erzeugten Code/Typen/RTTI selber betreffen.

Die Hilfe sagt natürlich rein garnichts, zu [Weak] bei Typen. Und in der Hilfe zum WeakAttribute steht wirklich GARNICHTS (nur der bekannte nichtssagende Schrott).

Delphi-Quellcode:

type
  IWeakInterface = [Weak] IInterface;  // Hier sträubt sich das Error-Insight und der Compiler.
  [Weak] IWeakInterface = IInterface;  // Geht das?
  [Weak] IWeakInterface = type IInterface;  // Und ist das richtig?

var
  Liste: TList<IWeakInterface>;

[Daniel]

Zitat von himitsu:

aber wie definiert man eigentlich eine Liste mit Weak-Referenzen?

Eigene Listen-Klasse mit eigenem Listen-Objekt, welches seinerseits die weak-Referenz auf Deine Interfaces beinhaltet und entsprechend kommunizieren kann, ob da noch etwas ist oder nicht.

[Stevie]

Delphi-Quellcode:

program WeakRefListTests;

uses
  TestFramework,
  TestInsight.DUnit,
  Spring,
  Spring.Collections;

type
  TWeakRefListTest = class(TTestCase)
  published
    procedure ListDoesNotKeepStrongReference;
  end;

  IRefCounted = interface
    function GetRefCount: Integer;
    property RefCount: Integer read GetRefCount;
  end;

  TRefCounted = class(TInterfacedObject, IRefCounted);

procedure TWeakRefListTest.ListDoesNotKeepStrongReference;
var
  sut: IList<WeakReference<IRefCounted>>;
  ref: IRefCounted;
begin
  sut := TCollections.CreateList<WeakReference<IRefCounted>>;
  ref := TRefCounted.Create;
  sut.Add(ref);
  CheckEquals(1, ref.RefCount);
  ref := nil;
  CheckFalse(sut[0].IsAlive);
  ref := sut[0];
  CheckNull(ref);
end;

begin
  RegisterTest(TWeakRefListTest.Suite);
  RunRegisteredTests();
end.

[himitsu]

Nja, dachte daß Delphi sowas auch selber kann.

Die [Weak]-Referenzen werden doch auch nicht auf nil gesetzt, sondern sind dann einfach nur "ungültige" Zeiger.
Aber das Problem gibt es nicht, da sich die Interfaces selber überall raus löschen, wenn sie freigegeben werden. (die kennen die Gegenseite, da sie selber eine gezählte Referenz besitzen, oder sie kennen wen, der den kennt)

Nur dürfen diese Referenzen halt nicht gezählt werden, damit sie sich freigeben können.

Für einzelne Variablen und Felder geht das Einfach, aber wie man das für Listen/Arrays deklariert, ist nirgendwo beschrieben, obwohl es irgendwie gehen soll.

[Daniel]

Zitat von himitsu:

Die [Weak]-Referenzen werden doch auch nicht auf nil gesetzt, sondern sind dann einfach nur "ungültige" Zeiger.

ehm. Na doch. Das ist doch gerade der Witz an einem Weak-Pointer. Der kennt nur zwei stabile Zustände: "Gültige Referenz" oder "NIL".

[Sir Rufo]

Dazu hatten wir schon was

http://www.delphipraxis.net/183253-a...nicht-arc.html