Conteggio di riferimento per oggetti

Question

Nel mio codice uso una piccola classe di memorizzazione dei dati, creata in luoghi diversi. Per evitare perdite di memoria e di semplificare le cose, voglio usare il conteggio dei riferimenti, così ho fatto

type TFileInfo = class (TInterfacedObject, IInterface) 

e rimosso tutte le mie chiamate manuali ai TFileInfo.Free. Sfortunatamente Delphi ha riportato molte perdite di memoria. Cercando sul così ho trovato la seguente questione spiegando perché questo non funziona:

Why aren't descendants of TInterfacedObject garbage collected?

C'è una soluzione presentata lì, ma mi richiede (almeno se ho capito bene) per scrivere un'interfaccia personalizzata IFileInfo e fornirlo con un sacco di getter e setter, che voglio evitare.

EDIT Vorrei aggiungere che inserisco il creare FileInfo oggetti in due diversi tipi di tabelle hash: una discendente da TBucketList e un altro è un'implementazione hash mappa dal forum CodeGear. Internamente entrambi i puntatori degli utenti, quindi la situazione è come nell'altra domanda.

C'è qualche altra possibilità di creare oggetti in Delphi usando il conteggio dei riferimenti?

Answer 1

Purtroppo, il compilatore Delphi genera il codice necessario per inc conteggio di riferimento/dicembre solo quando si utilizza interfacce (nel tuo caso interfaccia personalizzata IFileInfo). Inoltre, se le interfacce sono gettate sul puntatore (o TObject per quella materia), di nuovo non è possibile il conteggio dei riferimenti. Ad esempio, assume di elenco globale variabile: TList:

var ifi : IFileInfo; 
begin 
    ifi := TFileInfo.Create; 
    list.Add(TFileInfo(ifi)); 
end; 

dopo la lista metodo restituisce [list.Count - 1] conterrà penzoloni puntatore.

Per cui le interfacce non possono essere utilizzate in una mappa di hash che li inserisce in puntatori, l'implementazione di hashmap deve mantenerli come IInterface.

Answer 2

Questa funzionalità viene fornita per le interfacce ma non per gli oggetti.

È possibile creare qualcosa di simile, ma è necessario sostituire alcune delle strutture di TObject:

TRefCountObject = class (TObject) 
private 
    FRefCount : Integer; 
public 
    constructor Create; 

    procedure Free; reintroduce; 

    function RefCountedCopy: TRefCountObject; 
end; 


constructor TRefCountObject.Create; 
begin 
    inherited; 
    FRefCount := 1; 
end; 

procedure TRefCountObject.Free; 
begin 
    if self=nil then Exit; 
    Dec(FRefCount); 
    if FRefCount<=0 then 
    Destroy; 
end; 

function TRefCountObject.RefCountedCopy: TRefCountObject; 
begin 
    Inc(FRefCount); 
    Result := self; 
end; 

È necessario RefCountedCopy per assegnare l'oggetto a un'altra variabile. Ma poi hai un oggetto conteggiato.

Come utilizzare questo:

var1 := TRefCountObject.Create; // rc = 1 
var2 := var1.RefCountedCopy;  // rc = 2 
var3 := var1.RefCountedCopy;  // rc = 3 
var2.Free;      // rc = 2 
var1.Free;      // rc = 1 
var4 := var3.RefCountedCopy;  // rc = 2 
var3.Free;      // rc = 1 
var4.Free;      // rc = 0 

Answer 3

C'è una lunga spiegazione a questo, ma in breve: Ereditare da TInterfacedObject (e non chiamare Free te stesso), non è sufficiente, devi usare un oggetto-factory-dynamic per creare gli oggetti per te, e usare l'interfaccia -indicatori sull'oggetto ovunque, non solo sulle variabili di riferimento dell'oggetto. (Sì, ciò significa che non puoi semplicemente passare "vecchio codice" senza guardarlo)

Answer 4

Non mescolare riferimenti a oggetti e riferimenti di interfaccia.

var 
    Intf: IInterface; 
    Obj: TFileInfo; 

begin 
    // Interface Reference 
    Intf := TFileInfo.Create; // Intf is freed by reference counting, 
          // because it's an interface reference 
    // Object Reference 
    Obj := TFileInfo.Create; 
    Obj.Free; // Free is necessary 

    // Dangerous: Mixing 
    Obj := TFileInfo.Create; 
    Intf := Obj; // Intf takes over ownership and destroys Obj when nil! 
    Intf := nil; // reference is destroyed here, and Obj now points to garbage 
    Obj.Free; // this will crash (AV) as Obj is not nil, but the underlying object 
      // is already destroyed 
end; 

Answer 5

Il conteggio dei riferimenti in Delphi funziona solo se si dispone di un riferimento alla propria istanza tramite un'interfaccia. Non appena mischi i riferimenti all'interfaccia e i riferimenti di classe, allora sei nei guai.

In sostanza si desidera il conteggio dei riferimenti senza la necessità di creare un'interfaccia con tutti i metodi e le proprietà definite in essa. Ci sono tre modi per farlo, e questi sono all'incirca nell'ordine in cui li consiglierei.

1. Barry Kelly ha scritto un post su Smart Pointers. Utilizza Generics in Delphi 2009, ma sono abbastanza sicuro che potresti codificarlo con le versioni specifiche del tipo che stai utilizzando se non stai ancora utilizzando il 2009 (è una grande versione di BTW).

2. Un altro modo che funziona con più versioni di Delphi e meno modifiche è il value type wrapper di Janez Atmapuri Makovsek. È un esempio implementato per TStringList, ma è possibile adattarlo a qualsiasi tipo.

3. Il terzo modo è creare un puntatore interfacciato (simile a Smart Pointer di Barry, ma non così intelligente). Credo che ce ne sia uno in JCL, ma di sicuro non ricordo i dettagli. Fondamentalmente questa è un'interfaccia che accetta un riferimento TObject in fase di costruzione. Quindi quando il conteggio dei riferimenti raggiunge lo zero, chiama gratuitamente sull'oggetto che gli hai passato. Questo metodo funziona solo per le istanze di breve durata che non passano come parametri perché si separa il riferimento conteggiato di riferimento dal riferimento effettivamente utilizzato. Suggerirei invece uno degli altri due metodi, ma se preferisci questo metodo e vuoi maggiori informazioni fammelo sapere.

Quella è la cosa su Delphi, ci sono modi liberi di realizzare le cose. L'opzione numero 1 è la migliore secondo me - Ottieni Delphi 2009 e usa quel metodo se puoi.

Buona fortuna!

Answer 6

Per aggiungere a ciò che è già stato detto, se si desidera memorizzare i riferimenti alle interfacce, invece di utilizzare un TList, utilizzare un TInterfaceList . Il conteggio ref funzionerà in modo coerente.

Answer 7

Se si desidera eliminare le chiamate gratuite su istanze TObject, è possibile che si desideri esaminare un garbage collector per Delphi nativo. Sono a conoscenza di 2 diversi netturbini e una tecnica di raccolta dei rifiuti, ciascuno con pro e contro.

• Native Precise Tracking Garbage Collector da Henrick Hellström

• API for Boehm Garbage Collector DLL da Barry Kelly

• Garbage Collector for Delphi Objects and Components da Rossen Assenov (non un collezionista vero e spazzatura, più di un sacchetto di memoria.)

Uno di quelli probabilmente funzionerà per te.