Manually destroy C# objects

I am fairly new开发者_StackOverflow社区 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#? I know about the IDisposable interface, but suppose I'm dealing with a class which I didn't write and it doesn't implement it? It wouldn't have a .Dispose() method, so that and using { } is out, and .Finalize is always either protected or private so that's not an option either.

(I am just trying to learn what is possible in C# in this case. I suppose if all else fails I could inherit the hypothetical ImNotDisposable class so that it does implement IDisposable.)

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.

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.

Although you can trigger garbage collection (you need to trigger GC for all generations because you can't be sure which generation the finalizable object is in) you cannot necessarily force finalization of a particular object. You can only depend upon assumptions about how the garbage collector works.

Furtnermore, since finalization happens on its own thread, you should call WaitForPendingFinalizers after triggering garbage collection.

GC.Collect(GC.MaxGeneration);
GC.WaitForPendingFinalizers();

As was noted by others, this can actually hurt your application's performance because unnecessarily invoking the GC can promote otherwise short-lived objects into higher generations which are more expensive to collect and are collected less frequently.

Generally speaking, a class that implements a finalizer (destructor) and does not implement IDisposable is frowned upon. And anything that implements IDisposable should be calling it's finalizer logic and supressing itself from finalization at garbage collection.

Jeff Richter recently posted a nice little trick for receiving a notification when garbage collection occurs.

Another great article on Garbage Collector Basics and Performance Hints by Rico Mariani (MSFT)

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.

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.

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.

It's not possible to destroy an object in a deterministic fashion. The CLR determines when the flagged object is reclaimed. This means that while you can flag an object for reclamation and ensure that managed and unmanaged resources are tidied up for disposal (by implementing the IDisposable pattern), the actual time the memory is released is up to the CLR. This is different from C++ where you could actually delete something and it would be released then.

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.