[C#] Problema di memory leak

[alex783]

Ciao a tutti.
Mi sono accorto di un fastidioso problema di memory leak in C# che non riesco davvero a risolvere.

Mi spiego:
ho un form1 con un semplice pulsante che non fa altro che aprire un altro form2 .
Quando chiudo poi questo form2 e lo riapro con lo stesso pulsante del form1, noto dal task manager che la memoria occupata dal mio programma cresce senza limiti ogni qualvolta ripeto questa operazione.

Giusto per rendervi l'idea, se all'apertura l'applicazione occupa circa 3.5MB, se apro e chiudo il form2 per una decina di volte, l'occupazione cresce a 8MB, nonostante io provveda a chiudere la finestra - con il metodo Close() - e non a nasconderla con Hide().

Non so se mi sono spiegato bene...

P.S: ho provato anche a liberare le risorse con Dispose() ma non ho risolto assolutamente niente.

Grazie a chi mi vorrà dare un aiuto.

[supertonno]

Originariamente inviato da alex783

Ciao a tutti.
Mi sono accorto di un fastidioso problema di memory leak in C# che non riesco davvero a risolvere.

Mi spiego:
ho un form1 con un semplice pulsante che non fa altro che aprire un altro form2 .
Quando chiudo poi questo form2 e lo riapro con lo stesso pulsante del form1, noto dal task manager che la memoria occupata dal mio programma cresce senza limiti ogni qualvolta ripeto questa operazione.

Giusto per rendervi l'idea, se all'apertura l'applicazione occupa circa 3.5MB, se apro e chiudo il form2 per una decina di volte, l'occupazione cresce a 8MB, nonostante io provveda a chiudere la finestra - con il metodo Close() - e non a nasconderla con Hide().

Non so se mi sono spiegato bene...

P.S: ho provato anche a liberare le risorse con Dispose() ma non ho risolto assolutamente niente.

Grazie a chi mi vorrà dare un aiuto.

In teoria fatta la Dispose() dovresti essere a posto.
Attenzione però, la dispose, non implica le deallocazione istantanea dell'oggetto, ma "marca" l'oggetto come deallocabile. Ci pensa piu il garbage colletor di .Net a liberare la memoria, quando lo ritiene piu opportuno...

[tomminno]

Dovresti postare un esempio di codice che verifica il tuo problema.
Se ci sono apparenti memory leak è perchè mantieni qualche riferimento appeso da qualche parte per cui il GC non interviene.
Oppure il GC non interviene nonostante che il tuo codice sia corretto perchè non ritiene che sia necessario, ma è decisamente l'opzione meno probabile.

[alex783]

Originariamente inviato da supertonno

In teoria fatta la Dispose() dovresti essere a posto.
Attenzione però, la dispose, non implica le deallocazione istantanea dell'oggetto, ma "marca" l'oggetto come deallocabile. Ci pensa piu il garbage colletor di .Net a liberare la memoria, quando lo ritiene piu opportuno...

Originariamente inviato da tomminno

Dovresti postare un esempio di codice che verifica il tuo problema.
Se ci sono apparenti memory leak è perchè mantieni qualche riferimento appeso da qualche parte per cui il GC non interviene.
Oppure il GC non interviene nonostante che il tuo codice sia corretto perchè non ritiene che sia necessario, ma è decisamente l'opzione meno probabile.

Allora... innanzittutto grazie per le vostre risposte...

Allego al post un esempio: un'applicazione banale con due form.
Provate ad aprire la finestra Form2 dal pulsante del Form1, poi chiudete la finestra Form2 e ripetete l'operazione. Dal task manager si vede che l'occupazione di memoria dell'applicazione cresce ogni volta.
Non credo sia normale un comportamento del genere.

Qui il codice:
Form1:

public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Form2 Window = new Form2();
            Window.Show();
        }
    }

Form2:

public partial class Form2 : Form
    {
        public Form2()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            
            this.Dispose();
            this.Close();
        }
    }

Come si può fare per risolvere questo problema?

P.S:
in questo esempio la memoria cresce lentamente perché si tratta di due stupidi form senza alcun controllo, ma vi assicuro che se si tratta di una finestra piena di controlli, l'occupazione di memoria cresce in modo considerevole.

[alex783]

up

Ah, tra l'altro mi sono accorto anche che dopo aver richiamato il metodo "Close", l'oggetto Form2 viene effettivamente distrutto, tant'è che se provo a richiamarlo, mi viene sollevata un'eccezione di NullObjectReference (o qualcosa del genere). Ma allora come mai non viene liberata la memoria dal GC?

[||ElChE||88]

Provato con GC.Collect()?

[MarcoGG]

Originariamente inviato da alex783

up

Ah, tra l'altro mi sono accorto anche che dopo aver richiamato il metodo "Close", l'oggetto Form2 viene effettivamente distrutto, tant'è che se provo a richiamarlo, mi viene sollevata un'eccezione di NullObjectReference (o qualcosa del genere). Ma allora come mai non viene liberata la memoria dal GC?

Infatti. .Close() già da solo basterebbe a fare tutto.
.Dispose() non forza l'eliminazione dell'oggetto e il rilascio della memoria occupata nello stesso preciso istante in cui viene invocato, ma piuttosto "marca" l'oggetto in questione per il prossimo passaggio di GC.
In soldoni, senza stare a fare grandi discorsi sui massimi sistemi, direi che il comportamento "anomalo" riscontrato nella gestione della memoria in .Net, è dovuto principalmente a 2 fattori :

1. Il GC ha dei tempi "tutti suoi", spesso imperscrutabili. Bisogna lasciarlo fare. Tu dici che aprendo N Form2 da Form1 la memoria cresce continuamente, ma non è corretto. In effetti GC interviene ( nel suo solito modo "pigro", ma credo sia volutamente così ). Se ad esempio apri 10 Form2, poi chiudi la decima, non notando alcun decremento di uso della Ram, poi magari riapri una decima Form2 e stranamente la memoria occupata diminuisce...
GC.Collect() a mio parere non è una buona idea : anzitutto nella maggior parte dei casi non noterai alcuna ottimizzazione della Ram, secondariamente può essere anche "pericoloso" ( su molti Forum, anche su MSDN, spesso e volentieri ne viene sconsigliato l'uso )...

2. Non dimentichiamo che lo stesso Windows gioca un ruolo importante e che "storicamente" l'ottimizzazione della Ram non è mai stata un cavallo di battaglia. Perciò la colpa di tutto ciò si distribuisce nella catena Applicazione-FrameWork-Windows...

Possibile soluzione : tempo fa ho avuto il tuo stesso problema e l'ho risolto creandomi una piccola classe static con qualche metodo di gestione della Ram, prova questo ( dovrebbe dare una bella scrollatina alla memoria... ) :

        public static void OttimizzaMemoria() 
        {
            System.Diagnostics.Process CP = System.Diagnostics.Process.GetCurrentProcess();
            try
            {
                CP.MaxWorkingSet = (IntPtr)((int)CP.MaxWorkingSet - 1);
            }
            catch (System.Exception) 
            {
                //...
            }
        }

Chiamalo semplicemente dopo il .Close() del Form2... e dimmi che effetto ti fa !

[sottovento]

Sicuro che sia DAVVERO un memory leak? Mi sembra un po' presto per dirlo.
Prova a fare dei test piu' lunghi. Tutto sommato 8Mb sono ancora pochi, magari gc non si e' ancora deciso ad intervenire

[||ElChE||88]

Originariamente inviato da MarcoGG

GC.Collect() a mio parere non è una buona idea : anzitutto nella maggior parte dei casi non noterai alcuna ottimizzazione della Ram, secondariamente può essere anche "pericoloso" ( su molti Forum, anche su MSDN, spesso e volentieri ne viene sconsigliato l'uso )...

GC.Collect() è assoluatmente da evitare nel codice normale, ma in questo caso potrebbe indicare se il problema è del GC o del codice...

[alex783]

Originariamente inviato da MarcoGG

Infatti. .Close() già da solo basterebbe a fare tutto.
.Dispose() non forza l'eliminazione dell'oggetto e il rilascio della memoria occupata nello stesso preciso istante in cui viene invocato, ma piuttosto "marca" l'oggetto in questione per il prossimo passaggio di GC.
In soldoni, senza stare a fare grandi discorsi sui massimi sistemi, direi che il comportamento "anomalo" riscontrato nella gestione della memoria in .Net, è dovuto principalmente a 2 fattori :

1. Il GC ha dei tempi "tutti suoi", spesso imperscrutabili. Bisogna lasciarlo fare. Tu dici che aprendo N Form2 da Form1 la memoria cresce continuamente, ma non è corretto. In effetti GC interviene ( nel suo solito modo "pigro", ma credo sia volutamente così ). Se ad esempio apri 10 Form2, poi chiudi la decima, non notando alcun decremento di uso della Ram, poi magari riapri una decima Form2 e stranamente la memoria occupata diminuisce...
GC.Collect() a mio parere non è una buona idea : anzitutto nella maggior parte dei casi non noterai alcuna ottimizzazione della Ram, secondariamente può essere anche "pericoloso" ( su molti Forum, anche su MSDN, spesso e volentieri ne viene sconsigliato l'uso )...

2. Non dimentichiamo che lo stesso Windows gioca un ruolo importante e che "storicamente" l'ottimizzazione della Ram non è mai stata un cavallo di battaglia. Perciò la colpa di tutto ciò si distribuisce nella catena Applicazione-FrameWork-Windows...

Possibile soluzione : tempo fa ho avuto il tuo stesso problema e l'ho risolto creandomi una piccola classe static con qualche metodo di gestione della Ram, prova questo ( dovrebbe dare una bella scrollatina alla memoria... ) :

        public static void OttimizzaMemoria() 
        {
            System.Diagnostics.Process CP = System.Diagnostics.Process.GetCurrentProcess();
            try
            {
                CP.MaxWorkingSet = (IntPtr)((int)CP.MaxWorkingSet - 1);
            }
            catch (System.Exception) 
            {
                //...
            }
        }

Chiamalo semplicemente dopo il .Close() del Form2... e dimmi che effetto ti fa !

Ehm... quando invoco questo metodo, la memoria occupata scende da 5MB a 1.5MB Ottimo!

Grazie mille!

[MarcoGG]

Originariamente inviato da alex783

Ehm... quando invoco questo metodo, la memoria occupata scende da 5MB a 1.5MB Ottimo!

Grazie mille!

[Kralizek]

mi spiegheresti cosa fa quella chiamata?

[alex783]

Originariamente inviato da Kralizek

mi spiegheresti cosa fa quella chiamata?

Ho trovato questo su MSDN: http://msdn.microsoft.com/it-it/libr...et(VS.80).aspx

[tomminno]

Non è una mossa intelligente ridurre lo spazio di memoria dell'applicativo.

Se si vuole il controllo completo della memoria è bene cambiare linguaggio.

Altrimenti si prendono gli aspetti positivi del .NET trascurando gli inconvenienti (se questi costituiscono effettivamente un problema)

[Steel Jans]

Si vede che non hai ancora visto all'opera i componenti Timer... quelli si che ciucciano memoria se non stati attento!
Comunque non preoccuparti più di tanto perché in ogni caso non puoi cambiare la situazione. dot net comunque ha un sistema per il garbage collection che esegue automaticamente al verificarsi di determinate condizioni.

[MarcoGG]

Originariamente inviato da tomminno

Non è una mossa intelligente ridurre lo spazio di memoria dell'applicativo.

Se si vuole il controllo completo della memoria è bene cambiare linguaggio.

Altrimenti si prendono gli aspetti positivi del .NET trascurando gli inconvenienti (se questi costituiscono effettivamente un problema)

Quindi la tua "mossa intelligente", a chi chiede come ottimizzare l'utilizzo di memoria sviluppando in C#, è consigliare... di cambiare linguaggio ?

[!k-0t1c!]

Piuttosto che andare a pasticciare con il working set, che in caso può anche causare rallentamenti notevoli ed altri problemi se impostato male, forse vale la pena di forzare la collection di oggetti di generazioni più recenti da parte del GC..!

[alex783]

Originariamente inviato da MarcoGG

Quindi la tua "mossa intelligente", a chi chiede come ottimizzare l'utilizzo di memoria sviluppando in C#, è consigliare... di cambiare linguaggio ?

Il tuo metodo sta funzionando alla grande e per ora non sto riscontrando alcuna anomalia

Purtroppo era un problema a cui tenevo molto risolvere, perché la mia applicazione deve restare caricata nella traybar, e non voglio che occupi 20MB, se non di più, anche quando non fa nulla.

Ora, invece, occupa sì 20 MB quando esegue i task, ma appena finisce, scende ad appena 1.5 MB

[gugoXX]

Lascia tutto com'e'. Quando il sistema avra' bisogno di memoria, oppure quando il sistema non sara' particolarmente sotto stress, Il Garbage Collector passera' da solo e liberera' la memoria per altri processi.
La memoria resta in questo momento allocata per futuri usi. Poiche' allocare memoria costa tempo, la scelta e' quella di tenerla allocata fino a che non serve effettivamente per altro, sperando in un futuro riuso dello spazio gia' allocato dal Framework.
Il fatto che forzare GC.Collect() liberi la memoria e' segno che non c'e' alcun Memory Leak, in presenza dei quali il Garbage Collector non potrebbe fare molto.

[MarcoGG]

Originariamente inviato da !k-0t1c!

Piuttosto che andare a pasticciare con il working set, che in caso può anche causare rallentamenti notevoli ed altri problemi se impostato male, forse vale la pena di forzare la collection di oggetti di generazioni più recenti da parte del GC..!

1. Nessun pasticcio. Ho usato quel sistema in un'applicazione recentemente senza alcun problema. Se fosse così dannoso credo che, alla versione 2008 di C#, dovrebbe essere quantomeno deprecato.
Certo non consiglio di farlo in un Timer, o ad ogni click di un pulsante, ovvio. Sempre usare buon senso.

2. Beh, fatti un giretto su MSDN e molti altri Forum di Programmazione, e non troverai poi molta gente che consiglia di forzare GC.