What is the difference between Dispose and Finalize methods?

Dispose is explicitly called by the developer or the runtime environment (e.g., using) to release unmanaged resources. Finalize (via destructor in C#) is called by the garbage collector when the object is destroyed if it has not been explicitly released.

Criterion	Dispose	Finalize (via destructor)
Call	Explicitly set by the developer (using, Dispose())	Automatically set by the garbage collector
Runtime	Deterministic	Non-deterministic (depends on the garbage collector)
Purpose	Release both managed and unmanaged resources	Release only unmanaged resources
Implementation	IDisposable interface	Override Object.Finalize method (via destructor syntax)
Usage	Preferred way to release resources	Backup mechanism for unmanaged resources

Example of using using (automatic call to Dispose):

// Example of using a class implementing IDisposable
using (var fileStream = new System.IO.FileStream("myfile.txt", System.IO.FileMode.Open))
{
    // Work with the file
} // Here, fileStream.Dispose() is called automatically

Example of a class with IDisposable and destructor:

using System;

public class MyDisposableClass : IDisposable
{
    private IntPtr unmanagedResource; // Represents an unmanaged resource
    private bool disposed = false;

    public MyDisposableClass()
    {
        // Initialize unmanaged resource
        unmanagedResource = System.Runtime.InteropServices.Marshal.AllocHGlobal(100);
        Console.WriteLine("Resource allocated.");
    }

    // Implementation of IDisposable
    public void Dispose()
    {
        Dispose(true);
        // Suppress finalization since the resource is already released
        GC.SuppressFinalize(this);
        Console.WriteLine("Dispose() called.");
    }

    // Protected virtual method for releasing resources
    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Release managed resources (if any)
                Console.WriteLine("Releasing managed resources.");
            }

            // Release unmanaged resources
            if (unmanagedResource != IntPtr.Zero)
            {
                System.Runtime.InteropServices.Marshal.FreeHGlobal(unmanagedResource);
                unmanagedResource = IntPtr.Zero;
                Console.WriteLine("Unmanaged resource released.");
            }

            disposed = true;
        }
    }

    // Destructor (finalizer)
    ~MyDisposableClass()
    {
        Dispose(false); // Only release unmanaged resources
        Console.WriteLine("Finalizer called.");
    }
}

The Dispose method should be implemented for all classes managing unmanaged resources (files, network connections, handles, etc.). Finalize should be used as a fallback to release unmanaged resources if Dispose was not called. Classes implementing Finalize should suppress its call in Dispose(true) to avoid double releasing of resources.