Memory Management Using Finalize And Dispose Method

using System;

namespace FinalizeDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            FinalizeDemo d = new FinalizeDemo();
            d = null;
            Console.ReadLine();
        }
    }

    class FinalizeDemo
    {
        public FinalizeDemo()
        {
            Console.WriteLine("Object Created");
        }

        ~FinalizeDemo()
        {
            Console.WriteLine("Destructor Called.");
        }
    }
}

Note. Even though we assigned null to the object, we cannot predict when the memory will be de-allocated. To make the memory de-allocated immediately, we can call GC.Collect() method.

In .NET, we have one more way to clear the unmanaged memory.

Dispose of Method

Dispose method is also used for unmanaged resources like connections, files, etc. This method belongs to the IDisposable interface. IDisposable interface has only one method i.e. Dispose. To clear all the unmanaged resources held by a class, we need to inherit that class from the IDisposable interface and implement the Dispose method. We have to write all the cleanup code in DisposeMethod. Whenever we want to free the resources held by the object, we can call the Dispose method.

using System;

namespace FinalizeDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            FinalizeDemo d = new FinalizeDemo();
            d.Dispose();
            d = null;

            Console.ReadLine();
        }
    }

    class FinalizeDemo : IDisposable
    {
        public FinalizeDemo()
        {
            Console.WriteLine("Object Created");
        }

        ~FinalizeDemo()
        {
            Console.WriteLine("Destructor Called.");
        }

        public void Dispose()
        {
            Console.WriteLine("Dispose Method Called");
        }
    }
}

There is a problem with this approach. If the user forgets to call the Dispose method, there will be a memory leak. To overcome this problem, it's recommended to use Dispose and Finalize together. Thus, if a user forgets to call the Dispose method, the Garbage Collector can call the Finalize method and clear all the memory, held by the object. Below is the code snippet to implement Dispose and Finalize. Instead of writing the same logic in the Dispose method and destructor, we will be creating a Dispose Method, which accepts a Boolean parameter. This method can be called from the destructor or from the Dispose () method.

using System;

namespace FinalizeDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            FinalizeDemo d = new FinalizeDemo();
            d.Dispose();
            d = null;
            
            Console.ReadLine();
        }
    }
    class FinalizeDemo : IDisposable
    {
        private bool Disposed = false;

        public FinalizeDemo()
        {
            Console.WriteLine("Object Created");
        }

        ~FinalizeDemo()
        {
            Console.WriteLine("Destructor Called.");
            Dispose(false);
        }
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        public void Dispose(bool disposing)
        {
            if (!Disposed)
            {
                if (disposing)
                {
                    Console.WriteLine("Called From Dispose");
                    // Clear all the managed resources here
                }
                else
                {
                    // Clear all the unmanaged resources here
                }
                Disposed = true;
            }
        }
    }
}

Here, we have taken a Boolean variable Disposed = false. Now, we have two scenarios

1. If a user calls the Dispose method: Here, we are checking whether an object has been disposed of or not. Now, when we call this method from the Dispose method of the IDisposable interface, we pass true. In the if block, we will write all the cleanup code, and then outside it, we will set the Disposed variable to true.
2. If a user forgets to call the Dispose method: In this case Destructor, we will call the Dispose Method with false, and control will go to the else block inside the Dispose method. Here, we will write all the cleanup code.

.NET introduced the use block to take care of calling the Dispose method if a class is implementing the IDisposable interface. Hence, it’s a good practice to create an object within the using block.