Quando dovrei creare un distruttore?

Per esempio:

public class Person
{
    public Person()
    {
    }

    ~Person()
    {
    }
}

Quando devo creare manualmente un distruttore? Quando hai avuto bisogno di creare un distruttore?

AGGIORNAMENTO: Questa domanda è stata l'oggetto del mio blog nel maggio 2015 . Grazie per l'ottima domanda! Consulta il blog per un lungo elenco di falsità che le persone credono comunemente nella finalizzazione.

Quando devo creare manualmente un distruttore?

Quasi mai.

In genere si crea un distruttore solo quando la classe si sta aggrappando ad alcune costose risorse non gestite che devono essere ripulite quando l'oggetto scompare. È meglio utilizzare il modello usa e getta per assicurarsi che la risorsa venga ripulita. Un distruttore è quindi essenzialmente una garanzia che se il consumatore dell'oggetto dimentica di smaltirlo, alla fine la risorsa verrà comunque ripulita. (Può essere.)

Se fai un distruttore fai molta attenzione e comprendi come funziona il garbage collector . I distruttori sono davvero strani :

• Non corrono sul tuo thread; corrono sul proprio thread. Non causare deadlock!
• Un'eccezione non gestita generata da un distruttore è una cattiva notizia. È sul suo filo; chi lo prenderà?
• Un distruttore può essere chiamato su un oggetto dopo l'avvio del costruttore ma prima del termine del costruttore. Un distruttore correttamente scritto non farà affidamento sugli invarianti stabiliti nel costruttore.
• Un distruttore può "resuscitare" un oggetto, rendendo di nuovo vivo un oggetto morto. È davvero strano. Non farlo
• Un distruttore potrebbe non correre mai; non puoi fare affidamento sull'oggetto mai pianificato per la finalizzazione. E ' probabilmente sarà, ma non è una garanzia.

Quasi nulla di ciò che è normalmente vero è vero in un distruttore. Stai molto, molto attento. Scrivere un distruttore corretto è molto difficile.

Quando hai avuto bisogno di creare un distruttore?

Durante il test della parte del compilatore che gestisce i distruttori. Non ho mai avuto bisogno di farlo nel codice di produzione. Raramente scrivo oggetti che manipolano risorse non gestite.

Si chiama "finalizzatore" e di solito dovresti crearne uno solo per una classe il cui stato (es: campi) include risorse non gestite (es. Puntatori a handle recuperati tramite chiamate p / invoke). Tuttavia, in .NET 2.0 e versioni successive, esiste in realtà un modo migliore per gestire la pulizia di risorse non gestite: SafeHandle . Detto questo, non dovresti praticamente mai più scrivere un finalizzatore.

Non ne hai bisogno a meno che la tua classe mantenga risorse non gestite come gli handle di file di Windows.

Si chiama distruttore / finalizzatore e di solito viene creato durante l'implementazione del modello Disposed.

È una soluzione di fallback quando l'utente della tua classe dimentica di chiamare Dispose, per assicurarsi che (eventualmente) le tue risorse vengano rilasciate, ma non hai alcuna garanzia su quando viene chiamato il distruttore.

In questa domanda Stack Overflow , la risposta accettata mostra correttamente come implementare il modello di disposizione. Ciò è necessario solo se la tua classe contiene risorse non gestite che Garbage Collector non riesce a ripulire.

Una buona pratica è quella di non implementare un finalizzatore senza dare anche all'utente della classe la possibilità di disporre manualmente l'oggetto per liberare immediatamente le risorse.

Quando hai risorse non gestite e devi assicurarti che vengano ripulite quando il tuo oggetto scompare. Un buon esempio potrebbe essere gli oggetti COM o i gestori di file.

Ho usato un distruttore (solo a scopo di debug) per vedere se un oggetto veniva rimosso dalla memoria nell'ambito di un'applicazione WPF. Non ero sicuro che la garbage collection stesse veramente eliminando l'oggetto dalla memoria, e questo era un buon modo per verificarlo.

I distruttori forniscono un modo implicito di liberare risorse non gestite incapsulate nella tua classe, vengono chiamate quando il GC vi si avvicina e chiamano implicitamente il metodo Finalize della classe base. Se si utilizzano molte risorse non gestite, è meglio fornire un modo esplicito di liberare tali risorse tramite l'interfaccia IDisposable. Consulta la guida alla programmazione C #: http://msdn.microsoft.com/en-us/library/66x5fx1b.aspx