5

The consensus on best practice for resource-intensive operations, such as opening database connections, seems to be to use Using blocks, because the Using block "guarantees disposal of the resource... even in the case of an unhandled exception.".

Here is how most examples I've found are written:

Sub ExecuteCommand(ByVal sql As String, ByVal connectionString As String)
    Using connection As New SqlConnection(connectionString)
        Dim command As New SqlCommand(sql, connection)
        command.Connection.Open()
        command.ExecuteNonQuery()
    End Using
End Sub

But nested Using blocks are allowed, and I occasionally (but rarely) see the above written as:

Sub ExecuteCommand(ByVal sql As String, ByVal connectionString As String)
    Using connection As New SqlConnection(connectionString)
        Using command As New SqlCommand(sql, connection)
            command.Connection.Open()
            command.ExecuteNonQuery()
        End Using
    End Using
End Sub

My question: Is there any benefit to multiple nested Using blocks? Or does a single Using block already guarantee that all of the resources it contains will be disposed?

(Note: my code is in VB.NET, but the same question applies to C#.)

Improve this question
1
  • Nested Usings are very common in graphics related code where you might be Using a Graphics object, a Brush, some Pens and a Bitmap at the same time. Commented Oct 4, 2013 at 18:27

5 Answers 5

Reset to default
10

the using block "guarantees disposal of the resource... even in the case of an unhandled exception."

Take that "guarantee" with a grain of salt. Many things can prevent the disposal of the resource. What if the using block contains an infinite loop? Or the block throws an exception, a hostile exception filter higher on the stack goes into an infinite loop and never returns control to the finally block associated with the using statement? Or the block calls Environment.FailFast? There are many, many things that can prevent the disposal from ever running. Never write a program that relies on disposal for its correctness. Disposal is there for politeness, to return scarce resources to the pool for others to use them.

Moreover, let me make sure this point is clear: truly unhandled exceptions are implementation-defined behavior in C#. The using block's finally clause is there to deal with the situation where an exception is thrown inside the using block and then handled somewhere else, not to deal with the situation where an exception is thrown inside the block and never handled. If that happens then it is entirely up to the implementation to determine what happens; the C# language makes a total of zero promises about the behavior of a program that throws an exception that is never handled. The resources might be disposed. They might not. You're in a building that is about to be unexpectedly demolished; do you really want to spend time washing the dishes and putting them away neatly?

Is there any benefit to multiple nested Using blocks?

Yes.

Does a single Using block already guarantee that all of the resources it contains will be disposed?

No. Only the resources that are actually mentioned by a using statement are cleaned up. That's why you nest them.

There are a few cases where technically you don't have to because the inner one takes responsibility for releasing the same resource as the outer one. But it doesn't hurt anything to nest using blocks and it makes it very clear to the reader what is going on. The best practice here is to have one using statement for every resource that you want cleaned up.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

8

Nested using blocks are definitely useful: a single block will call Dispose only on its own variable, not on other variables that may be opened inside the same block. That is why each variable that you want to clean up at a defined point in your program (which should be every variable of type implementing IDisposable) needs its own using block.

Improve this answer

1 Comment

+1 for answering does a single Using block already guarantee that all of the resources it contains will be disposed?
3

The Using statement will dispose the variables declared within the Using line.
It has no effect on variables declared elsewhere in the block.

You should always use a Using statement for every disposable variable.

Improve this answer

1 Comment

Not disagreeing with your answer whatsoever, but it might help to make it very clear that the answer to the second part of the question does a single Using block already guarantee that all of the resources it contains will be disposed? is NO.
1

All other answers are correct. I'll add one more point.

If objects are of same type c# compiler provides a way(syntatic sugar) to use multiple objects in single using statement inline.

C# version

using (MemoryStream ms1 = new MemoryStream(), ms2 = new MemoryStream())
{

}

Vb.Net version

Using ms1 = New MemoryStream(), ms2 = New MemoryStream()

End Using

This will dispose both the MemoryStreams

Improve this answer

4 Comments

Interesting. Does VB.NET allow something similar?
For some reason, people seem to not use this instead of the nested syntax. I always thought this way superior
@GaryWalker: In most scenarios, you aren't simultaneously using two resources of the same type. In C# you can omit curly braces (and the corresponding indentation) around all but the innermost using block, though not everyone is a fan of that strategy. I'm not sure if that technique is applicable to VB.Net.
Of course, it is only useful when it applies. But it more obvious that the to resources are related when you write it this way.
1

Nested using statements are quite useful. However many programmers don't consider that the SqlCommand object needs to have resource cleanup. I.e., the resource is the connection, not the command.

ADDED

SqlCommand does not have a Close() method, so even though SqlCommand has a Dispose() method, the lack of a Close() method indicates that there is really "nothing to close / release". Disposable instances will always be Disposed eventually. Hard to find something authoritative without digging through source, but when asked in this article the MS guy was asked exactly what it disposed, he said "Actually not a lot ..." and went on to suggest a USING clause for the SqlCommand(), so I answered the question correctly, but avoided the fuzziness behind it initially.

Improve this answer

1 Comment

When you say "many programmers consider...", is that how the language actually operates? That is, will the command be disposed when the connection is? The other answers here don't seem to support that.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.