Newsgroup: it.comp.lang.visual-basic
Titolo: VB.NET Dispose... mi sono perso qualcosa?

Sto sviluppando un programma con varie forms, e ad ogni apertura di
ognuna di esse usando
Dim a As New MiaForm : a.ShowDialog()
la memoria utilizzata cresce... E mai diminuisce, nemmeno quando
chiudo la form!
Non dovrebbe essere il Garbage Collector a liberare le risorse quando
esco dalla mia funzione?
In ogni caso, anche un a.Dispose non risolve niente.
Cosa sto sbagliando?

 esco dalla mia funzione?
Per quanto ne so, il GC elimina gli oggetti quando ritiene necessario 
(finalizzazione non deterministica), altrimenti restano in cache a tempo 
indeterminato.
Prova a un certo punto a richiamare esplicitamente il metodo 
GC.Collect() per vedere cosa succede. E' comunque sconsigliato usarlo 
sistematicamente, perch� introduce un elevato overhead, e di fatto 
annulla i benefici di GC.
-- 
news:it-alt.comp.software.openoffice : Il newsgroup dedicato a
OpenOffice.org, la suite open source di applicazioni per ufficio.
Saluti, VITRIOL

 GC.Collect() per vedere cosa succede.
Assolutamente niente...
La sparo: è possibile che debba fare il .Dispose di tutti i controlli
nella form?

 nella form?
Di tutti credo di no, ma dipende da cosa fai nel form. Se usi oggetti 
che espongo l'interfaccia IDisposable, � buona norma richiamare 
esplicitamente il metodo Dispose quando si � finito di utilizzare l'oggetto.


 esplicitamente il metodo Dispose quando si è finito di utilizzare l'oggetto.
zac
oppure (succedeva anche in vb6...e in genere in tutti i linguaggi)
basta un figlio ancora vivo...per tenere in vita il padre!
Le form son contenitori...se il contenitore è vuoto o pieno di roba
"eliminabile"...il contenitore viene eliminato!
Se il contenitore contiene roba viva (ad esempio una classe usata da
un altra form...o una proprietà...o un dataset usato da
altri...)....la forma viene mantenuta in vita !
fermo restando che qui parli di "macchine virtuali" e la memoria di
cui parli non è memoria mappata nelle ram direttamente!
A meno di errori logici ...può crescere quanto gli pare non ti
preoccupare...ci pensa il GC a gestire tutto!
Ossia
in dotnet a meno di bug logici ci pensa il GC a ottimizzare il tutto!
Noterai come la dimensione occupata varierà da macchina a macchina e
da processore a processore...per una volta...fidati del GC!


wrote:

Mi è piaciuto il discorso della "roba viva" :D
Se è così, allora mi fido!

 Cosa sto sbagliando?
Probabilmente non stai sbagliando nulla :-) In breve: se usi oggetti 
istanziati da classi che implementano l'interfaccia IDisposable, allora è 
buona norma invocare esplicitamente Dispose prima che il riferimento 
all'oggetto vada out of scope. In generale, il consiglio è di usare la 
keyword Using in fase di costruzione dell'oggetto in modo da rendere 
implicita l'invocazione di Dispose
La classe Form è un caso particolare, perchè se visualizzi un form usando il 
metodo Show() allora l'invocazione di Dispose è "gratis" (nel senso che il 
runtime lo invoca automaticamente quando l'utente chiude il form). Se invece 
lo visualizzi con ShowDialog(), è tuo compito invocare Dispose (c'è un 
motivo dietro questa scelta, ma sarebbe lungo da spiegare quindi... 
soprassediamo :-) )
Tutto ciò premesso, Dispose *non* rilascia la memoria ma le risorse 
"unmanaged", ossia quelle sulle quali il CLR non ha giurisdizione (es: 
handle grafici). La memoria sarà rilasciata *solo* quando il CLR "deciderà" 
di far fare al GC il suo... Sporco lavoro. La logica con la quale ciò viene 
"deciso" è abbastanza articolata, ma concettualmente si può riassumere in: 
"il CLR lancia il GC quando fallisce una allocazione di memoria a causa di 
assenza di sufficiente memoria libera nello heap o eccessiva frammentazione 
della stessa". In poche parole... Lascia fare a lui :-)
-- 
.A
GUISA - 
http://www.guisa.org
UGIdotNET - 
http://www.ugidotnet.org
Read my blog at: 
http://blogs.ugidotnet.org/pape