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
No, Disposing of the SqlCommand will not effect the Connection. A better approach would be to also wrap the SqlConnection in a using block as well: using (SqlConnection conn = new SqlConnection(connstring)) { conn.Open(); using (SqlCommand cmd = new SqlCommand(cmdstring, conn)) { cmd.ExecuteNonQuery(); } } Otherwise, the Connection is unchanged by the fact that a … Read more
All Component classes implement a Disposed event. You can add an event handler for that event and clean up things in there. For example, in your UserControl you could add following method: private void OnDispose(object sender, EventArgs e) { // do stuff on dispose } And in constructor (or in Load event handler) add the … Read more
Following the Inteface Segregation Principle of SOLID if you add the IDisposable to the interface you are giving methods to clients that are not interested in so you should add it to A. Apart from that, an interface is never disposable because disposability is something related with the concrete implementation of the interface, never with … Read more
Four things that will cause Dispose to not be called in a using block: A power failure on your machine when inside the using block. Your machine getting melted by an atomic bomb while in the inside of the using block. Uncatchable exceptions like StackOverflowException, AccessViolationException and possibly others. Environment.FailFast
The finalizer is used as a fall-back if the object is not disposed properly for some reason. Normally the Dispose() method would be called which removes the finalizer hookup and turns the object into a regular managed object that the garbage collector easily can remove. Here is an example from MSDN of a class that … 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.)
You need to override the Dispose method from Form Typically this is automatically overridden in the RestartForm.Designer.cs file, so you will need to move the dispose into your code file so that you can add whatever code you need to add without it being rewritten by the designer. In the RestartForm.cs protected override void Dispose(bool … Read more
No, you don’t need to worry about this. The fact that they return an IDisposable implementation is an implementation detail – it’s because iterator blocks in the Microsoft implementation of the C# compiler happen to create a single type which implements both IEnumerable<T> and IEnumerator<T>. The latter extends IDisposable, which is why you’re seeing it. … 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