Qual è la differenza tra l'utilizzo di IDisposable e un distruttore in C #?

Quando implementerei IDispose su una classe anziché su un distruttore? Ho letto questo articolo , ma ancora mi manca il punto.

La mia ipotesi è che se implemento IDispose su un oggetto, posso esplicitamente "distruggerlo" invece di aspettare che lo faccia il garbage collector. È corretto?

Ciò significa che dovrei sempre chiamare esplicitamente Dispose su un oggetto? Quali sono alcuni esempi comuni di questo?

Un finalizzatore (noto anche come distruttore) fa parte della garbage collection (GC) - è indeterminato quando (o anche se) ciò accade, poiché GC si verifica principalmente a causa della pressione della memoria (cioè necessita di più spazio). I finalizzatori vengono generalmente utilizzati solo per ripulire le risorse non gestite , poiché le risorse gestite avranno la propria raccolta / eliminazione.

Quindi IDisposableè usato per pulire deterministicamente gli oggetti, cioè adesso. Non raccoglie la memoria dell'oggetto (che appartiene ancora a GC), ma viene utilizzato ad esempio per chiudere file, connessioni al database, ecc.

Ci sono molti argomenti precedenti su questo:

• finalizzazione deterministica
• disporre gli oggetti
• utilizzando il blocco
• risorse

Infine, tieni presente che non è raro che un IDisposableoggetto abbia anche un finalizzatore; in questo caso, di Dispose()solito chiama GC.SuppressFinalize(this), il che significa che GC non esegue il finalizzatore, semplicemente butta via la memoria (molto più economico). Il finalizzatore viene comunque eseguito se ti dimentichi Dispose()dell'oggetto.

Il ruolo del Finalize()metodo è garantire che un oggetto .NET possa ripulire le risorse non gestite durante la garbage collection . Tuttavia, oggetti come connessioni al database o gestori di file dovrebbero essere rilasciati il ​​prima possibile, invece di fare affidamento sulla raccolta dei rifiuti. Per questo dovresti implementare l' IDisposableinterfaccia e rilasciare le tue risorse nel Dispose()metodo.

C'è un'ottima descrizione su MSDN :

L'utilizzo principale di questa interfaccia è il rilascio di risorse non gestite . Il Garbage Collector rilascia automaticamente la memoria allocata a un oggetto gestito quando tale oggetto non viene più utilizzato. Tuttavia, non è possibile prevedere quando avverrà la garbage collection . Inoltre, il garbage collector non è a conoscenza di risorse non gestite come gli handle di finestre o di file e flussi aperti .

Utilizzare il metodo Dispose di questa interfaccia per rilasciare in modo esplicito le risorse non gestite insieme al Garbage Collector. Il consumatore di un oggetto può chiamare questo metodo quando l'oggetto non è più necessario.

L'unica cosa che dovrebbe essere in un distruttore C # è questa riga:

Dispose(False);

Questo è tutto. Nient'altro dovrebbe mai essere in quel metodo.

La tua domanda sull'opportunità o meno di chiamare sempre Disposeè di solito un acceso dibattito. Vedi questo blog per una prospettiva interessante da parte di persone rispettate nella comunità .NET.

Personalmente, penso che la posizione di Jeffrey Richter sia quella che chiama Dispose non è obbligatoria sia incredibilmente debole. Fornisce due esempi per giustificare la sua opinione.

Nel primo esempio, dice che chiamare Disposei controlli Windows Form è noioso e non necessario negli scenari tradizionali. Tuttavia, non menziona che in Disposerealtà viene chiamato automaticamente dai contenitori di controllo in quegli scenari tradizionali.

Nel secondo esempio, afferma che uno sviluppatore può presumere erroneamente che l'istanza da IAsyncResult.WaitHandledebba essere eliminata in modo aggressivo senza rendersi conto che la proprietà inizializza pigramente l'handle di attesa con conseguente riduzione delle prestazioni non necessaria. Ma il problema con questo esempio è che lo IAsyncResultstesso non aderisce alle linee guida pubblicate da Microsoft per la gestione degli IDisposableoggetti. Cioè, se una classe contiene un riferimento a un IDisposabletipo, la classe stessa dovrebbe implementare IDisposable. Se IAsyncResultseguisse quella regola, il suo Disposemetodo potrebbe prendere la decisione riguardo a quale dei suoi membri costituenti necessita di essere smaltito.

Quindi, a meno che qualcuno non abbia un argomento più convincente, rimarrò nel campo "chiama sempre Dispose" con la consapevolezza che ci saranno alcuni casi marginali che sorgono principalmente da scelte di progettazione sbagliate.

È piuttosto semplice in realtà. So che è stata data una risposta, ma riproverò ma cercherò di mantenerlo il più semplice possibile.

Un distruttore in genere non dovrebbe mai essere utilizzato. È solo run .net vuole che funzioni. Funzionerà solo dopo un ciclo di garbage collectoin. Potrebbe non essere mai effettivamente eseguito durante il ciclo di vita dell'applicazione. Per questo motivo, non dovresti mai inserire alcun codice in un distruttore che "deve" essere eseguito. Inoltre, non è possibile fare affidamento sull'esistenza di oggetti esistenti all'interno della classe quando viene eseguita (potrebbero essere già stati ripuliti poiché l'ordine in cui vengono eseguiti i distruttori non è garantito).

IDisposible dovrebbe essere utilizzato ogni volta che si dispone di un oggetto che crea risorse che necessitano di essere ripulite (ad esempio, handle di file e grafici). In effetti, molti sostengono che tutto ciò che si inserisce in un distruttore dovrebbe essere messo in IDisposable per i motivi sopra elencati.

La maggior parte delle classi chiamerà dispose quando viene eseguito il finalizzatore, ma questo è semplicemente lì come una guardia sicura e non dovrebbe mai essere invocato. Dovresti eliminare esplicitamente tutto ciò che implementa IDisposable quando hai finito. Se implementi IDisposable, dovresti chiamare dispose nel finalizer. Vedi http://msdn.microsoft.com/en-us/library/system.idisposable.aspx per un esempio.

Ecco un altro bell'articolo che elimina un po 'della nebbia che circonda IDisposable, il GC e smaltisci.

Chris Lyons WebLog Demystifying Dispose