Qual è la differenza tra i metodi Dispose e Finalize?

Dispose viene chiamato esplicitamente dallo sviluppatore o dall'ambiente di esecuzione (ad esempio, using) per liberare risorse non gestite. Finalize (tramite il distruttore in C#) viene chiamato dal garbage collector durante la distruzione dell'oggetto, se non è stato liberato esplicitamente.

Criterio	Dispose	Finalize (tramite il distruttore)
Chiamata	Specificata esplicitamente dallo sviluppatore (using, Dispose())	Automatica dal garbage collector
Tempo di esecuzione	Deterministico	Non deterministico (dipende dal garbage collector)
Scopo	Liberare risorse gestite e non gestite	Liberare solo risorse non gestite
Implementazione	Interfaccia IDisposable	Sovrascrittura del metodo Object.Finalize (tramite il distruttore)
Utilizzo	Metodo preferito per liberare risorse	Meccanismo di riserva per risorse non gestite

Esempio di utilizzo di using (chiamata automatica a Dispose):

// Esempio di utilizzo di una classe che implementa IDisposable
using (var fileStream = new System.IO.FileStream("myfile.txt", System.IO.FileMode.Open))
{
    // Lavorare con il file
} // Qui viene chiamato automaticamente fileStream.Dispose()

Esempio di classe con IDisposable e distruttore:

using System;

public class MyDisposableClass : IDisposable
{
    private IntPtr unmanagedResource; // Rappresenta una risorsa non gestita
    private bool disposed = false;

    public MyDisposableClass()
    {
        // Inizializzazione della risorsa non gestita
        unmanagedResource = System.Runtime.InteropServices.Marshal.AllocHGlobal(100);
        Console.WriteLine("Risorsa allocata.");
    }

    // Implementazione di IDisposable
    public void Dispose()
    {
        Dispose(true);
        // Sopprime il finalize, poiché la risorsa è già stata liberata
        GC.SuppressFinalize(this);
        Console.WriteLine("Dispose() chiamato.");
    }

    // Metodo protetto virtuale per liberare risorse
    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Liberare risorse gestite (se presenti)
                Console.WriteLine("Risorse gestite liberate.");
            }

            // Liberare risorse non gestite
            if (unmanagedResource != IntPtr.Zero)
            {
                System.Runtime.InteropServices.Marshal.FreeHGlobal(unmanagedResource);
                unmanagedResource = IntPtr.Zero;
                Console.WriteLine("Risorsa non gestita liberata.");
            }

            disposed = true;
        }
    }

    // Distruttore (finalizer)
    ~MyDisposableClass()
    {
        Dispose(false); // Liberare solo risorse non gestite
        Console.WriteLine("Finalizer chiamato.");
    }
}

Il metodo Dispose deve essere implementato in tutte le classi che gestiscono risorse non gestite (file, connessioni di rete, handle, ecc.). Finalize dovrebbe essere usato come meccanismo di riserva per liberare risorse non gestite nel caso in cui Dispose non venga chiamato. Le classi che implementano Finalize devono sopprimere la sua chiamata in Dispose(true) per evitare la doppia liberazione delle risorse.