Unless you expect the publisher of the event to outlive the subscriber, there’s no reason to remove the event handler, no. This is one of those topics where folk lore has grown up. You really just need to think about it in normal terms: the publisher (e.g. the button) has a reference to the subscriber. … Read more
A couple of corrections should be made here: Regarding the answer from Phil Devaney: “…Calling Dispose allows you to do deterministic cleanup and is highly recommended.” Actually, calling Dispose() does not deterministically cause a GC collection in .NET – i.e. it does NOT trigger a GC immediately just because you called Dispose(). It only indirectly … Read more
As per MS Docs: try-finally (C# Reference) Within a handled exception, the associated finally block is guaranteed to be run. However, if the exception is unhandled, execution of the finally block is dependent on how the exception unwind operation is triggered. That, in turn, is dependent on how your computer is set up. As you … Read more
Garbage collection is for memory. You need to dispose of non-memory resources – file handles, sockets, GDI+ handles, database connections etc. That’s typically what underlies an IDisposable type, although the actual handle can be quite a long way down a chain of references. For example, you might Dispose an XmlWriter which disposes a StreamWriter it … Read more
The fact that you need to ensure that the object is disposed indicates a design flaw. It’s fine if disposing is the polite or efficient thing to do, but it should not be semantically necessary. There is no way to enforce that an object is disposed of via the using statement. However, what you can … Read more
IDisposable has nothing to do with freeing memory. IDisposable is a pattern for freeing unmanaged resources — and memory is quite definitely a managed resource. The links pointing to GC.Collect() are the correct answer, though use of this function is generally discouraged by the Microsoft .NET documentation. Edit: Having earned a substantial amount of karma … Read more
Destructor implicitly calls the Finalize method, they are technically the same. Dispose is available with objects that implement the IDisposable interface. You may see : Destructors C# – MSDN The destructor implicitly calls Finalize on the base class of the object. Example from the same link: class Car { ~Car() // destructor { // cleanup … Read more
Asking for modifications like this is pointless, the Windows Forms team has been disbanded quite a while ago. It is in maintenance mode, only security issues and OS incompatibilities are considered. It is otherwise simple enough to create your own method to do this: public static class ExtensionMethods { public static void Clear(this Control.ControlCollection controls, … Read more
The GC does not call Dispose, it calls your finalizer (which you should make call Dispose(false)). Please look at the related posts on the side or look up the C# best practices for the Dispose pattern (The docs on IDisposable explain it quite well IIRC.)
I don’t think there is a real memory leak. The problem is that you don’t dispose the old bitmap, it is up to the GC to clean the stuff. But there is no deterministic way to say when this will happen. So i think if you’re going to loop through a lot of pictures, you’ll … Read more