C# dispose vs finalize – Understanding the difference between dispose and finalize in C#

Last updated on March 27th, 2023 at 10:14 pm

Dispose() and finalize() are two important methods used for releasing resources in C#. These methods are used for cleaning up resources like database connections and files if they are no longer required. but there are some significant differences between the dispose and finalize methods in C#.

In C#, Dispose() and Finalize() are methods that are used to release unmanaged resources held by an object. The Dispose() method is defined in the IDisposable interface, whereas the Finalize() method is defined in the Object class. The Dispose() method can be called explicitly by the user, whereas Finalize() method is automatically called by the GC (garbage collector) before an object is destroyed.

In this article, we will explore the differences between Dispose and Finalize and learn when to use them.

What is Dispose() method?

Dispose is a method that is called explicitly by the developer to release the resources that are no longer required. It is implemented in the IDisposable interface, which is then implemented by the types that hold onto unmanaged resources. The dispose method is used to release resources such as database connections, file handles, and memory.

What is Finalize() method?

Finalize is a method that is called internally by the garbage collector when an object is being collected. It is used to release unmanaged resources that are held by an object. The finalize method is called automatically by the garbage collector and we are not allowed to call this method directly.

Differences between Dispose and Finalize in C#

Here, We have a chart comparing some additional differences between Dispose and Finalize in C#.

Example: Implementing Dispose() method

Following is a sample code example of how to use the dispose method in C#:

    class MyClass : IDisposable
    {
        // Some unmanaged resource
        private IntPtr handle;

        public void Dispose()
        {
            // Release the unmanaged resource
            ReleaseHandle(handle);

            // Mark the object as disposed
            handle = IntPtr.Zero;
            GC.SuppressFinalize(this);
        }

        // Protected implementation of Dispose pattern.
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                // Free any other managed objects here.
                //
            }

            // Release the unmanaged resource
            ReleaseHandle(handle);

            // Mark the object as disposed
            handle = IntPtr.Zero;
        }

        // Use C# destructor syntax for finalization code.
        ~MyClass()
        {
            // Simply call Dispose(false).
            Dispose(false);
        }

        private void ReleaseHandle(IntPtr handle)
        {
            // Perform any necessary cleanup for the unmanaged resource here
            // ...

            // Release the handle
            handle = IntPtr.Zero;
        }
    }

Code Explanation:

We have defined a class MyClass that implements the IDisposable interface in the code mentioned above, which allows the object to be disposed when it is no longer required. This class contains an unmanaged resource, represented by an IntPtr handle.

The Dispose() method releases the unmanaged resource by calling the ReleaseHandle() method and then sets the handle to IntPtr.Zero to mark the object as disposed. The GC.SuppressFinalize() method is then called to prevent the object’s finalizer from being called again.

The Dispose(bool) method is a protected implementation of the Dispose pattern that is called by the Dispose() method to perform the actual resource cleanup. The method first checks the value of the disposing parameter, which indicates whether the method is being called from the Dispose() method (ex: disposing is true) or from the object’s finalizer (Ex: disposing is false).

If disposing is true, the method frees any managed objects that have been created. It then releases the unmanaged resource by calling the ReleaseHandle() method and sets the handle to IntPtr.Zero.

Disposing objects by Using block

The using statement is used to automatically call the Dispose method on the object when it goes out of scope.

using (var myObject = new MyClass())
{
    // Use the object here
}

The using block is used to dispose an object when you are finished with it. Here, Disposing of an object means releasing any resources that the object is holding. The using statement is important for objects that hold onto resources that are not automatically released by the garbage collector, such as file handles or database connections.

Example:

Here is another example of how to use the using block in C#:

using (FileStream fs = new FileStream("testFile.txt", FileMode.Open))
{
    // Use the object here.
}

In the above example, We have created a FileStream object and opened it for reading. When the using block is exited, the FileStream object is automatically disposed, which releases the file handle that it was holding onto. This is equivalent to calling the Dispose method on the object manually, like this:

FileStream fileStream = new FileStream("testFile.txt", FileMode.Open);
try
{
    // Use the object here.
}
finally
{  // Disposing object
    fileStream.Dispose();
}

Using Finalize method in C#

You need to define a destructor in the class in order to use finalize() method. The destructor will be called by the garbage collector when the object is being collected. Here, In the example below, the destructor calls the ReleaseHandle method to release the unmanaged resource and then sets the handle to null to mark the object as disposed.

You do not need to worry about calling the Finalize method yourself because you are aware that it cannot be called directly. The garbage collector will automatically make a call to it. However, you should be aware that finalize is slower than dispose because it is called by the garbage collector, and it should only be used as a last resort when an object holds onto unmanaged resources and does not implement the IDisposable interface.

class MyClass
{
    // Define some unmanaged resource
    private IntPtr handle;

    // Using C# destructor syntax for finalization code.
    ~MyClass()
    {
        // Release the unmanaged resource
        ReleaseHandle(handle);

        // Mark the object as disposed
        handle = IntPtr.Zero;
    }
}

Dispose method rules in C#

The following are a few rules that you should follow when using the dispose() method in C#:

• Implement the IDisposable interface: You need to implement the IDisposable interface to use the dispose method and provide a Dispose method implementation in your class.
• Release unmanaged resources: The Dispose method should release any unmanaged resources that are held by the object, such as file handles, database connections, memory, etc.
• Avoid unnecessary garbage collection: After calling the Dispose method, you should call the GC.SuppressFinalize method to prevent the Finalize method from being called and avoid unnecessary garbage collection. This is because the Finalize method is not needed if the Dispose method has already released the resources held by the object.
• Call Dispose on base class: If your class inherits from a class that implements IDisposable, you should call the Dispose method on the base class in your implementation of Dispose method.
• Mark the object as disposed: After releasing the resources, you should set any relevant object fields to null or a default value to mark the object as disposed.
• Handle multiple calls to Dispose: Your implementation of Dispose method should be able to handle being called multiple times without causing any issues. You make sure that the Subsequent calls to Dispose after the first one can simply return immediately.
• Use the using statement: To ensure that the Dispose method is called automatically, you should use the using statement when working with objects that implement IDisposable. This will ensure that the Dispose method is called when the object goes out of scope.

Finalize method rules in C#

The following are a few rules that you should follow when using the finalize() method in C#:

• Provide a destructor: You need to provide a destructor for your class in order to use the finalize method. The destructor will be called by the garbage collector when the object is being collected.
• Do not call finalize directly: The finalize method should not be called directly because it will be called automatically by the garbage collector.
• Avoid using finalize: You should avoid using finalize whenever possible because it is slower than the dispose method and should only be used as a last resort when an object holds onto unmanaged resources and does not implement the IDisposable interface.
• Do not throw exceptions in finalize: You should not throw exceptions from the finalize method because the garbage collector does not catch exceptions that are thrown from finalize. If an exception is thrown, it might terminate the process.

FAQ

Here are some common questions and answers about dispose and finalize in C#:

Reference: MSDN-Finalize method, Implement a Dispose method

You might also like:

• C# Struct vs Class |Top 15+ Differences Between C# Struct and Class
• C# Queue with examples
• Web API vs web service: Top 10+ Differences between web API and web service in C#
• C# Polymorphism: Different types of polymorphism in C# with examples
• C# Stack
• C# Hashtable
• Generic Delegates in C# With Examples
• IEnumerable Interface in C# with examples
• Constructors in C# with Examples
• C# Enum | How to Use enumeration type in C#?
• Properties In C# with examples
• 10 Difference between interface and abstract class In C#
• What is a delegate in C#? Multicast Delegate with Examples

• Author
• Recent Posts

Shekh Ali

Meet Shekh Ali, a skilled Software engineer and passionate blogger with an MCA degree and 8+ years of experience in the field. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Shekh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• Understanding the SOLID Principle: Single Responsibility Principle in C# - June 7, 2023
• Difference between var and dynamic in C# - May 26, 2023
• Understanding the Chain of Responsibility Design Pattern in C# - May 11, 2023