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
Yes, Dispose will be called. It’s called as soon as the execution leaves the scope of the using block, regardless of what means it took to leave the block, be it the end of execution of the block, a return statement, or an exception. As @Noldorin correctly points out, using a using block in code … Read more
Just do this: using(var connection = new SqlConnection(ConfigurationManager.ConnectionStrings[“MyConn”].ConnectionString)) using(var command = connection.CreateCommand()) { command.CommandText = “…”; connection.Open(); command.ExecuteNonQuery(); } Not calling dispose on the command won’t do anything too bad. However, calling Dispose on it will suppress the call to the finalizer, making calling dispose a performance enhancement.
As several others have pointed out in general this is not a problem. The only case it will cause you issues is if you return in the middle of a using statement and additionally return the in using variable. But then again, this would also cause you issues even if you didn’t return and simply … Read more
Do I need to Dispose a Form after closing the Form? When you show the form using Show() you don’t need to dispose it, because it will dispose after close. But when you show form using ShowDialog(), you need to dispose the form, because it won’t dispose after closing. When you close a Form, a … Read more
A couple of important points should be made to address the OP’s question: .NET GC is non-deterministic (i.e. you never know nor should you depend on when it happens) Dispose is never called by the .NET Framework; you must call it manually – preferably by wrapping its creation in a using() block. Explicitly setting a … Read more
Interesting blog post here: Dispose of a WPF UserControl (ish) It mentions subscribing to Dispatcher.ShutdownStarted to dispose of your resources.
A finalizer (aka destructor) is part of garbage collection (GC) – it is indeterminate when (or even if) this happens, as GC mainly happens as a result of memory pressure (i.e. need more space). Finalizers are usually only used for cleaning up unmanaged resources, since managed resources will have their own collection/disposal. Hence IDisposable is … Read more
There is a discussion about this in the MSDN forums. Stephen Toub, a member of the Microsoft pfx team has this to say: Task.Dispose exists due to Task potentially wrapping an event handle used when waiting on the task to complete, in the event the waiting thread actually has to block (as opposed to spinning … Read more
The finalizer method is called when your object is garbage collected and you have no guarantee when this will happen (you can force it, but it will hurt performance). The Dispose method on the other hand is meant to be called by the code that created your class so that you can clean up and … Read more