Deterministic Finalisation in Csharp

Monika Arora

15y3.7kVisual Basic .NET

I want to perform deterministic Finalisation in Csharp. How can I do that

5 Replies

Know the answer? Post it — somebody with the same question will find it here.

Jean Paul15y ago
Your reply was informative. Thank You Vulpes for sharing.
0
Vulpes15y ago
The short answer to the question is that you can't perform deterministic finalization in C# (or any other .NET language) of a particular object in the same way as you can do in, say, unmanaged C++.

As Jean said, you have no control over when the runtime will call an object's finalizer (destructor in C#), if it has one, and recover the heap memory it was using.

By implementing IDisposable, you can call an object's Dispose() method to clean up unmanaged resources (file handles, network connections etc.) immediately but the object will continue to exist in an unstable state until it is finally garbage collected. To minimize the time before that is done and to avoid accessing the object by mistake in the meantime, you need to remember to set all references to the object to null (if they won't otherwise go out of scope) as soon as you've called Dispose().

As Gyanendra said, the use of the 'using' statement rather than calling Dispose() directly can help with this task.

As regards deterministic finalization, the best you can do is to force a garbage collection by calling GC.Collect(). Although it's nearly always best to let the CLR manage memory for you, it can be a good idea to call this method in certain types of application where you don't want the GC to kick in when you're in the middle of some time critical operation. However, you still can't control the finalization of a particular object, though you can restrict garbage collection to a particular generation of objects.
0
Jean Paul15y ago
I will try to put my knowledge here.. but some minor defects will be there.

The Destructor and Finalize() are almost the same. The Destructor are converted into Finalize() method in the IL code.

Destructors are automatically called by the Garbace Collector and it is non-deterministic. But in certain cases we need to take control of it. (usually when dealing with unmanaged resources)

You can refer the article here: http://www.codeproject.com/KB/cs/NDestructors.aspx

GC.SuppressFinalize(this); // Call this inside the Dispose() method

There is also GC.KeepAlive(this); which is used to keep the instance alive even if no other object are refererring to it.
0
Mamta M15y ago
This reply sounds copy-pasted. Please include the source whenever you're providing material from another site, even if it's an answer. Just mention the link along with your answer, no harm in that.
0
Gyanendra Kumar Mishra15y ago
You can deterministically finalize any object that implements the IDisposable interface by invoking its Dispose() method. If you use C# you have the advantage of the using statement which allows you to define a scope at the end of which an object will be disposed. One of the most common examples given uses a SqlConnection object:
      using ( SqlConnection test = newSqlConnection( ... ) ) {

// code implementation

      } // SqlConnection.Dispose() is automatically invoked

At the end of this scope, the SqlConnection's Dispose() method is automatically invoked and all resources held by this object are released.
0