Menu
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#? 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.)
839
Use a tight scope around the variables (that's a pair of braces enclosing a sequence of statements). The variables are destroyed when the scope they're defined in is exited (and aren't created until the scope is entered). Otherwise, the answer's "No". Global variables can't be destroyed at all.
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.
Description. In C++, the operator delete destroys an object by calling its destructor, and then deallocates the memory where that object was stored. Occasionally, however, it is useful to separate those two operations. [1] Destroy calls an object's destructor without deallocating the memory where the object was stored.
Class members that are class types can have their own destructors. Both base and derived classes can have destructors, although destructors are not inherited. If a base class A or a member of A has a destructor, and a class derived from A does not declare a destructor, a default destructor is generated.
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.
40
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.
196
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
