This is a post about object finalization in .NET.
Finalization is not as inexpensive as we think, it increases the pressure put on GC.All objects that need finalization are moved into a finalizable queue and the actual finalization happens in a separate thread. Because the objects full state may be needed, the object itself and all the object it points to are promoted to the next generation (this is needed so that GC does not clean these objects off in the current round), and these objects are cleaned up only after the following GC.
Due to this reason, resources that need to be released should be wrapped in as small a finalizable object as possible, for instance if your class needs a reference to an unmanaged resource, then you should wrap the unmanaged resource in a separate finalizable class and make that a member of your class and furthermore the parent should be a non-finalizable
class. This approach will assure that only the wrapped class (class that contains the unmanaged resource) will be promoted.And as mentioned earlier the finalization occurs in a separate thread and furthermore there is only one finalization thread hence if a finalizer causes this thread to block, all the other objects needing finalization in the queue will not be called and your application will
Therefore, when implementing finalizers, keep it as simple as possible.A good practice to follow when the lifetime of an object is explicitly know, is to implement the dispose pattern, by implementing the IDisposable interface and calling it explicitly; or use the using statment to wrap you created instance, so that once the scope of the object is no longer valid the dispose method of the object is called.
A time may arise when you may at some places know the lifetime of the object but at some point you may not; in this case put your clean up code in a separate function, call that function in the finalizer and also in your dispose method, additioanlly call the GC.SupressFinalization() in your dispose method after the clean up method; this will inform GC not to run the finalizer.