How to guarantee memory cleanup using Dispose()

  
It's been said that Dispose() function cleans up the memory utilized by objects. Now consider a scenario where you have created an instance. 


.Net CLR may eventually call its Finalize() method, but Dispose() is never called automatically. Calling Dispose() method is the responsibility of consumer of your instance.

Now let's say you have called Dispose method explicitly. In the flow of execution if any exception is thrown before reaching to the call to Dispose() method, the memory leak can arise.

To resolve this issue C# provides a using keyword. Advantages of making use of using keyword it calls the Dispose() method in finally block. You can verify the code in MSIL.

try
{
}
finally
{
    IL_0010: 1dloc.0
    IL_0011: brfalse.s IL_0019
    IL_0013: ldloc.0
    IL_0014: callvirt instance void [mscorlib]system.IDisposable::dispose()
    IL_0019:endfinally
}

//Test.cs
using System;

namespace DisposePattern
{
    class Test
    {
        [STAThread]
        static void Main(string[] args)
        {
            using(Derived object1 = new Derived(1))
            {
                Derived object2 = new Derived(2);
            }
        }
    }
}

You can declare more than one reference in the using declaration:

using(Derived obj1 = new Derived(1), obj2 = new Derived(2))

The Dispose() method, in this case, will be called on each referenced object at the appropriate time.
You can also achieve this without making use of using keyword. What you have to do is to call Dispose() in finally block.

The using keyword in C# improves your chances of cleaning up your resources properly.