Manually destroy C# objects

Question

I am fairly new to learning C# (from Java & C++ background) and I have a question about manual garbage disposal: is it even possible to manually destroy an object in C#?

Answer 1

You can force the garbage collector to run after the variable you want to destroy goes out of scope, but you normally don't want to do that, as the garbage collector is more efficient if left to do its own work.

Forcing garbage collection can be done with GC.Collect, but don't do it. In my 10 years as a .NET developer, I have never needed it.

Answer 2

You don't manually destroy .Net objects. That's what being a managed environment is all about.

In fact, if the object is actually reachable, meaning you have a reference you can use to tell the GC which object you want to destroy, collecting that object will be impossible. The GC will never collect any object that's still reachable.

What you can do is call GC.Collect() to force a general collection. However, this almost never a good idea.

Instead, it's probably better to simply pretend any object that doesn't use unmanaged resources and is not reachable by any other object in your program is immediately destroyed. I know this doesn't happen, but at this point the object is just a block of memory like any other; you can't reclaim it and it will eventually be collected, so it may just as well be dead to you.

One final note about IDisposable. You should only use it for types that wrap unmanaged resources: things like sockets, database connections, gdi objects, etc, and the occasional event/delegate subscription.

Answer 3

No, you can't destroy a specific object.

It is possible to invoke the garbage collector, which will look for objects to destroy, but it's almost never a good idea.

Answer 4

Say you have a class matrix and you created two matrix objects aMatrix and bMatrix. In C# you can manually destroy (finalize) an object like so:

aMatrix = null;

GC.Collect();

The garbage collector will notice that your aMatrix is null and will destroy (finalize) it. Whether or not this is a good idea is a different story.

Answer 5

If the object is not reachable then you can call GC.Collect() and the object will be destroyed. The concept of IDisposable has nothing to do with the CLR and is mostly for user code to implement to perform additional disposal logic. Calling Dispose() on an object will not free the object itself from memory, though it may very well dispose any resources that this object references.

I should add that while what I said is a way to achieve this, in 99.9999% of applications you should never call GC.Collect() because it'll often degrade the performance of your application instead of improving it.

Answer 6

You can't manually destroy an object "like C++ delete", all what you can do is just close any exclusive resources the object has acquired and null all references to this object, so the GC can collect it, also don't call GC.Collect() by yourself, the GC process is expensive, as it has to suspend all other threads to safely collect the objects from memory, so just trust the GC, and it will kick off when needed.