[C#] Garbage Collector e Finalize()

[Ravenflot]

Buon anno a tutti !

Ho una domanda specifica sul Garbage Collector. Premetto che io mi riferisco al suo uso in C# (anche nel 3.0 ma immagino valga anche per il 2.0).
Sto leggendo un libro di questo linguaggio e sono arrivato alla trattazione di questo strumento.
So già che non si sa quando questo sia effettivamente chiamato etc etc. So anche che puoi implementare un distrutto ~NomeClasse che verrà chiamato dal GC automaticamente (infatti da codice normale non può essere chiamato) per farti rilasciare le risorse non gestite dal GC (cioè tutto ciò che è una risorsa che può essere utilizzata tramite un handle e comunque qualunque cosa che non sia un blocco di memoria nello heap). Ho anche letto che si può ricorrere all'interfaccia IDisposable per implementare un metodo pubblico Dispose() per chiamare la distruzione dell'oggetto da fuori [e la mia domanda si inserisce in questo punto] , metodo questo che , nella maggior parte degli esempi richiama un metodo con lo stesso nome ma con un flag booleano: è in questo metodo che avviene il rilascio delle risorse: il flag booleano lo si usa per capire da dove è stato chiamato: se dal codice (e allora si rilasciano le risorse managed oltre a quelle unmanaged) o dal distruttore (in questo caso si rilasciano solo le risorse unmanaged perchè alle managed ci penserà il GC essendo il distruttore invocato durante la pulizia del .NET framework.

La mia domanda riguarda la finalizzazione ed il metodo Finalize(). So che è un metodo che non può essere chiamato esplicitamente e lo richiama solo il GC quando è in esecuzione e questo metodo viene eseguito per ultimo, appena dopo il Dispose e quindi il distruttore e si occupa di liberare la memoria heap dalla variabile oggetto relativa. Questo è corretto ? Mi sembra di aver capito che sia l'ultima fase di pulizia, quella del richiamo della memoria nello heap (tralasciando il discorso della coda freachable che mi interessa fino ad un certo punto).
Le mie domande sono 2:
1) il metodo Finalize può essere alterato dal developer ? A me sembra di no: quello che può fare il developer è solo scritto nel Dispose o distruttore...
2) Come è possibile che Finalize sia richiamato all'interno di uno stesso oggetto ? Se fa parte di un oggetto allora come ultima cosa cancella se stesso ? Il mio quesito è proprio questo: il Finalize() mi dà l'idea di un metodo legato a qualcosa e finché è legato a qualcosa, questa cosa deve esistere

[gugoXX]

Buon anno a tutti !
...
Le mie domande sono 2:
1) il metodo Finalize può essere alterato dal developer ? A me sembra di no: quello che può fare il developer è solo scritto nel Dispose o distruttore...
2) Come è possibile che Finalize sia richiamato all'interno di uno stesso oggetto ? Se fa parte di un oggetto allora come ultima cosa cancella se stesso ? Il mio quesito è proprio questo: il Finalize() mi dà l'idea di un metodo legato a qualcosa e finché è legato a qualcosa, questa cosa deve esistere

1) Finalize e' di fatto il distruttore stesso.
Quando scrivi un distruttore in C#, che si scrive nello stesso modo del C++, stai facendo una cosa abbastanza simile al C++.
Scriverai:

~MiaClasse()
{
// Qualcosa
}

E il compliatore tradurra' in qualcosa come

protected override void Finalize()
{
try
{
// Qualcosa
}
finally
{
base.Finalize();
}
}


Ed e' l'ultima cosa che viene fatta sull'istanza prima di distruggere l'oggetto.
Anche se puo' essere usata per tante (perlopiu' inutili) cose, viene normalmente usata solo per liberare memoria risorse di tipo unmanaged, ovvero quella memoria e quelle risorse allocate dall'oggetto mediante chiamate al C++, oppure usando driver specifici che hanno bisogno di chiamate per liberare risorse, etc.
Invece la Dispose viene chiamata "quasi" esplicitamente. Se ne potrebbe fare a meno, scrivendo il codice che viene scritto nella Dispose all'interno del distruttore. Ma talvolta e' bene liberare la memoria prima possibile, senza aspettare il Garbage Collector (e senza chiamarne i metodi esplicitamente, che e' bruttino).
A qual punto puoi scrivere del codice nella Dispose, e forzare la dispose usando il costrutto USING, oppure chiamando la dispose esplicitamente (che e' di nuovo bruttino)
al termine dello USING infatti la dispose viene chiamata forzatamente, mentre la Finalize verra' chiamata solo da parte del Garbage Collector.

Spesso quindi il codice viene scritto nella Dispose e non nel Finalize.
Talvolta e' anche utile impedire al Garbage Collector di chiamare la Finalize, quando tutto e' stato fatto nella Dispose, mediante il metodo SuprressFinalize (chiamato appunto solitamente dalla Dispose stessa).

GC.SuppressFinalize(this);


Resta che se si rimane nel C#, o se non si usano risorse esterne esplicitamente pilotate, il distruttore e' proprio raro, e la Dispose non e' comune (PS: Un oggetto che non implementa Dispose non si puo' usare per definizione per uno Using, giacche' la Using serve solo per questo...)

[tomminno]

Resta che se si rimane nel C#, o se non si usano risorse esterne esplicitamente pilotate, il distruttore e' proprio raro, e la Dispose non e' comune (PS: Un oggetto che non implementa Dispose non si puo' usare per definizione per uno Using, giacche' la Using serve solo per questo...)

Dispose credo invece che debba essere abbastanza comune.
Qualunque classe abbia una variabile membro IDisposable dovrebbe essere a sua volta IDisposable.