.NET Framework provides two methods Finalize and Dispose for
releasing unmanaged resources like: Windows API created objects, File,
Database connection objects, COM objects.
It is always recommended to use Dispose method to clean
unmanaged resources. Do not implement the Finalize method until it is extremely
necessary
Dispose:
Dispose method belongs to ‘IDisposable’ interface. If any
object wants to release its unmanaged code, the best is to implement IDisposable and override
the Dispose method of IDisposable interface. Now once
your class has exposed the Dispose method, it is
the responsibility of the client to call the Dispose method to do the
cleanup.
How do I force the Dispose method to be called
automatically, as clients can forget to call Dispose method?
Call the Dispose method in Finalize method and in Dispose method, suppress
the finalize method using GC.SuppressFinalize.
Below is the sample code of the pattern. This is the best way we
do clean our unallocated resources and yes not to forget we do not get the hit
of running the Garbage collector twice.
public class CleanClass :
IDisposable
{
public void Dispose()
{
GC.SuppressFinalize(this);
}
~CleanClass()
{
Dispose();
}
}
Finalize:
.NET Garbage collector does almost all clean up activity for your objects. But
unmanaged resources (example: Windows API created objects, File, Database
connection objects, COM objects, etc.) are outside the scope of .NET Framework.
We have to explicitly clean our resources. For these types of objects, .NET
Framework providesObject.Finalize method.
What is the difference between Finalize() and Dispose() methods?
Dispose:
- Dispose
It belongs to IDisposable interface. and internal called by user code.
- Dispose
() of IDisposable interface is called by the programmer to explicitly
release resources when they are no longer being used. Dispose () can be
called even if other references to the object are alive.
- It
is called by user code and the class implementing dispose method must
implement IDisposable interface.It belongs to IDisposable
interface.Implement this when you are writing a custom class that will be
used by other users.There is no performance costs associated with Dispose
method
Finalize:
- Finalize
It belongs to Object class. and It's implemented with the help of
destructor in C#.
- Used
to free unmanaged resources like files, database connections, COM etc.
held by an object before that object is destroyed.Internally, it is called
by Garbage Collector and cannot be called by user code.
- The
finalizer method is called when your object is garbage collected and you
have no guarantee when this will happen (you can force it, but it will
hurt performance).
Why is it preferred to not use finalize for clean up?
The problem with finalize is that garbage collection has to make two rounds in order
to remove objects which have finalize methods.
Let us assume, there are three objects, Object1, Object2, and Object3.
Object2 has the finalize method overridden and remaining objects
do not have the finalize method overridden.
Now when garbage collector runs for the first time, it searches
for objects whose memory has to free. It can see three objects but only cleans
the memory for Object1 and Object3.
Object2 it pushes to the finalization queue.
Now garbage collector runs for the second time. It sees there
are no objects to be released and then checks for the finalization queue and at
this moment, it clears object2 from the memory.
So if you notice, object2 was released from memory in the second round and not
first. That is why the best practice is not to write clean up
non.NET/unmanaged resources in Finalize method rather use
the DISPOSE.
What
is the purpose of the Using block in C#?
The using statement allows the programmer to specify when
objects that use resources should release them. The object provided to the
using statement must implement the IDisposable interface. This interface
provides the Dispose method, which should release the object's resources.
public class Debuggersspace : IDisposable
{
//implementation details...
}
These
are equivalent:
Debuggersspace qa = new Debuggersspace ();
try
{
qa.Action();
}
finally
{
if (qa != null)
qa.Dispose();
}
In other words, the using statement tells .NET to release the object specified in the using block once it is no longer needed
using (Debuggersspace qa = new Debuggersspace ())
{
qa.Action();
}
Points to remember:
- If you declare the
variable outside the using block and then create a new instance in the using
statement it may not dispose the item
- So the using
statement will automatically dispose of the object once that context is complete.
- The using statement
is used to work with an object in C# that implements the
IDisposableinterface.
- The
IDisposable interface has one public method called Dispose that is used to dispose of the object.
- we use the using
statement, we don't need to explicitly dispose of the object in the code, the
using statement takes care of it.
C# Disposable pattern, Using, Dispose Vs Finalize:
Please refer below links for more information:
