Quelle est la différence entre les méthodes Dispose…

Dispose est appelé explicitement par le développeur ou par l’environnement d’exécution (par exemple, using) pour libérer des ressources non managées. Finalize (via le destructeur en C#) est appelé par le ramasse-miettes lors de la destruction de l’objet, si celui-ci n’a pas été libéré explicitement.

Critère	Dispose	Finalize (via le destructeur)
Appel	Spécifié explicitement par le développeur (`using`, `Dispose()`)	Automatique par le ramasse-miettes
Temps d’exécution	Déterministe	Non déterministe (dépend du ramasse-miettes)
But	Libérer des ressources gérées et non gérées	Libérer uniquement des ressources non gérées
Implémentation	Interface `IDisposable`	Surcharge de la méthode `Object.Finalize` (via le destructeur)
Utilisation	Méthode préférée pour libérer des ressources	Mécanisme de secours pour les ressources non gérées

Exemple d’utilisation de using (appel automatique à Dispose) :

// Exemple d’utilisation d’une classe implémentant IDisposable
using (var fileStream = new System.IO.FileStream("myfile.txt", System.IO.FileMode.Open))
{
    // Travailler avec le fichier
} // Ici, fileStream.Dispose() est appelé automatiquement

Exemple de classe avec IDisposable et destructeur :

using System;

public class MyDisposableClass : IDisposable
{
    private IntPtr unmanagedResource; // Représente une ressource non gérée
    private bool disposed = false;

    public MyDisposableClass()
    {
        // Initialisation de la ressource non gérée
        unmanagedResource = System.Runtime.InteropServices.Marshal.AllocHGlobal(100);
        Console.WriteLine("Ressource allouée.");
    }

    // Implémentation de IDisposable
    public void Dispose()
    {
        Dispose(true);
        // Supprimer la finalisation, car la ressource est déjà libérée
        GC.SuppressFinalize(this);
        Console.WriteLine("Dispose() appelé.");
    }

    // Méthode protégée virtuelle pour libérer les ressources
    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Libérer les ressources gérées (si présentes)
                Console.WriteLine("Libération des ressources gérées.");
            }

            // Libérer les ressources non gérées
            if (unmanagedResource != IntPtr.Zero)
            {
                System.Runtime.InteropServices.Marshal.FreeHGlobal(unmanagedResource);
                unmanagedResource = IntPtr.Zero;
                Console.WriteLine("Ressource non gérée libérée.");
            }

            disposed = true;
        }
    }

    // Destructeur (finaliseur)
    ~MyDisposableClass()
    {
        Dispose(false); // Libérer uniquement les ressources non gérées
        Console.WriteLine("Finaliseur appelé.");
    }
}

La méthode Dispose doit être implémentée dans toutes les classes gérant des ressources non gérées (fichiers, connexions réseau, descripteurs, etc.). Finalize doit être utilisé comme une option de secours pour libérer ces ressources si Dispose n’a pas été appelé. Les classes qui implémentent Finalize doivent supprimer son appel dans Dispose(true) pour éviter la double libération des ressources.

Quelle est la différence entre les méthodes Dispose et Finalize?