Difference Between Finalize and Dispose Method

 .Net Framework provides two methods Finalize and Dispose for releasing unmanaged resources like files, database connections, COM etc. This article helps you to understand the difference between Finalize and Dispose method.

Difference between Finalize & Dispose Method

Finalize

Dispose

Used to free unmanaged resources like files, database connections, COM etc. held by an object before that object is destroyed.

It is used to free unmanaged resources like files, database connections, COM etc. at any time.

Internally, it is called by Garbage Collector and cannot be called by user code.

Explicitly, it is called by user code and the class implementing dispose method must implement IDisposable interface.

It belongs to Object class.

It belongs to IDisposable interface.

Implement it when you have unmanaged resources in your code, and want to make sure that these resources are freed when the Garbage collection happens.

Implement this when you are writing a custom class that will be used by other users.

There is performance costs associated with Finalize method.

There is no performance costs associated with Dispose method.

For Example,

// Implementing Finalize method
public class MyClass 
{
 //At runtime C# destructor is automatically Converted to Finalize method.
 ~MyClass ()
 {
 //TO DO: clean up unmanaged objects
 }
}

For Example,

// Implementing Dispose method
public class MyClass : IDisposable
{
 private bool disposed = false;
 
 //Implement IDisposable.
 public void Dispose()
 {
 Dispose(true);
 }
 
 protected virtual void Dispose(bool disposing)
 {
 if (!disposed)
 {
 if (disposing)
 {
 //TO DO: clean up managed objects
 }
 
 //TO DO: clean up unmanaged objects
 
 disposed = true;
 }
 }
}

Note

1. You cannot override the Finalize method in the C# or C++ languages. But you can override Finalize method in VB.NET since it does not support destructor.
2. You should not implement a Finalize method for managed objects, because the garbage collector cleans up managed resources automatically.
3. A Dispose method should call the GC.SuppressFinalize() method for the object of a class which has destructor because it has already done the work to clean up the object, then it is not necessary for the garbage collector to call the object's Finalize method.

// Using Dispose and Finalize method
public class MyClass : IDisposable
{
 private bool disposed = false;
 
 //Implement IDisposable.
 public void Dispose()
 {
 Dispose(true);
 GC.SuppressFinalize(this);
 }
 
 protected virtual void Dispose(bool disposing)
 {
 if (!disposed)
 {
 if (disposing)
 {
 // TO DO: clean up managed objects
 }
 
 // TO DO: clean up unmanaged objects
 
 disposed = true;
 }
 }
 
 //At runtime C# destructor is automatically Converted to Finalize method
 ~MyClass()
 {
 Dispose(false);
 }
}