using various types in a using statement (C#)

Question

Since the C# using statement is just a syntactic sugar for try/finally{dispose} why does it accept multiple objects ONLY IF THEY ARE OF THE SAME TYPE?

I don't get it since all they need to be is IDisposable. If all of them implement IDisposable it should be fine but it isn't.

Specifically I am used to writing

using (var cmd = new SqlCommand())
{
    using (cmd.Connection)
    {
        // code
    }
}

which I compact into:

using (var cmd = new SqlCommand())
using (cmd.Connection)
{
    // code
}

and I would like to compact furthermore into:

using(var cmd = new SqlCommand(), var con = cmd.Connection)
{
    // code
}

but I can't. I could probably, some would say, write :

using((var cmd = new SqlCommand()).Connection)
{
    // code
}

since all I need to dispose is the connection and not the command but that's besides the point.

Answer 1

Other variable declarations in C# only allow you to declare multiple variables of the same type in the same statement; I don't see why using headers should be different.

Answer 2

I think this is actually a good idea. I would think it's just something that simply hasn't been implemented yet. I'd be surprised if there's an actual specific reason why this doesn't exist. I could be wrong though...

Answer 3

You can do this though:

using (IDisposable cmd = new SqlCommand(), con = (cmd as SqlCommand).Connection)
{
   var command = (cmd as SqlCommand);
   var connection = (con as SqlConnection);
   //code
}

Perhaps that would be satisfactory to you.

Answer 4

There's no particularly good technical reason; we could have come up with a syntax that allowed multiple declarations of nonhomogeneous types. Given that we did not, and there already is a perfectly good, clear, understandable and fairly concise mechanism for declaring nested using blocks of different types, we're unlikely to add a new syntactic sugar just to save a few keystrokes.