What is the difference between Dispose() and Finalize()?

Question

Ponu Maurya · Answer

In C#, Dispose() and Finalize() are both used to 
release unmanaged resources (like file handles, database connections, etc.), but they are used in
different ways and serve different purposes.
Dispose() (IDisposable Interface)
Explicit cleanup method.Called manually by the developer to release unmanaged resources.Belongs to the IDisposable interface.Often used in a using block, which automatically calls Dispose().
public class Resource : IDisposable
{
    private FileStream _file;
    public Resource(string path)
    {
        _file = new FileStream(path, FileMode.Open);
    }
    public void Dispose()
    {
        _file?.Dispose();  // Free unmanaged resource
        GC.SuppressFinalize(this); // Optional: tells GC not to call Finalize
    }
}
Use when: You want to explicitly and deterministically release resources.
Finalize() (Destructor)
Called by the Garbage Collector (GC) when the object is no longer in use.Cannot be called directly — handled automatically by the CLR.Used as a safety net in case Dispose() wasn’t called.Implemented via a destructor (~ClassName() in C#).
public class Resource
{
    ~Resource()
    {
        // Cleanup logic
    }
}
Drawbacks:
Runs on GC, so timing is non-deterministic.Expensive: keeps object in memory longer (until finalization).
Best Practice: Use Dispose() and Suppress Finalize
public class Resource : IDisposable
{
    private bool _disposed = false;
    ~Resource()
    {
        Dispose(false);
    }
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this); // Skip finalizer
    }
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Dispose managed resources
            }
            // Dispose unmanaged resources
            _disposed = true;
        }
    }
}
Summary Table
Feature
Dispose()
Finalize() (Destructor)
Called by
Developer (explicit)
GC (implicit)
Timing
Deterministic
Non-deterministic
Interface
Implements IDisposable
Implicit via ~ClassName()
Performance
Efficient
Slower (GC + finalizer queue)
Use case
Close files, DB, streams
Safety net for unmanaged cleanup

forum

What is the difference between Dispose() and Finalize()?

Anubhav Kumar

Can you answer this question?

1 Answers

`Dispose()` (IDisposable Interface)

`Finalize()` (Destructor)

Best Practice: Use `Dispose()` and Suppress Finalize

Summary Table

Liked By

Feature	`Dispose()`	`Finalize()` (Destructor)
Called by	Developer (explicit)	GC (implicit)
Timing	Deterministic	Non-deterministic
Interface	Implements `IDisposable`	Implicit via `~ClassName()`
Performance	Efficient	Slower (GC + finalizer queue)
Use case	Close files, DB, streams	Safety net for unmanaged cleanup