C#: using block: object re-initialization

Question

Re-initialization within "using" block is a bad idea, to be avoided at all times. Still i am going to ask this:

Why does "using" call dispose on the original value and not on the last reference or re-initialization (which happens if try finally block is used)

MyClass b = new MyClass();// implements Idisposable
MyClass c = new MyClass();
MyClass a ; 

 using (a = new MyClass())
 {
                a = b;
                a = c;
 }

In the above code dispose will be called on original reference and not the newer referenced. This can be easily verified by printing something on console in the dispose method.

However with try{} finally code the last reference dispose method is called.

try
{
   a = new MyClass();
   a = b;
   a = c;
 }
  finally 
   {
   a.Dispose();
  }

MSDN : The using statement ensures that Dispose is called even if an exception occurs while you are calling methods on the object.

using (Font font1 = new Font("Arial", 10.0f)) 
{
    byte charset = font1.GdiCharSet;
}

Basically "using" translates to:

{
  Font font1 = new Font("Arial", 10.0f);
  try
  {
    byte charset = font1.GdiCharSet;
  }
  finally
  {
    if (font1 != null)
      ((IDisposable)font1).Dispose();
  }
}

Answer 1

There are two forms of using statements defined in the C# specification:

using-statement:
    using   (    resource-acquisition   )    embedded-statement
resource-acquisition:
    local-variable-declaration
    expression

If you have a local-variable-declaration, there wouldn't be any questions. The variable will be read-only in the using block and you can't change it at all. The spec says:

8.13 The using statement

[...] In either expansion, the resource variable is read-only in the embedded statement.

Here, we're dealing with the second form: where resource-acquisition is expression and not a local-variable-declaration. In which case, the C# spec clearly says:

A using statement of the form

 using (expression) statement

has the same two possible expansions, but in this case ResourceType is implicitly the compile-time type of the expression, and the resource variable is inaccessible in, and invisible to, the embedded statement. [emphasis mine]

Obviously, you can't change an invisible, inaccessible variable. Its value is assigned only in the using resource-acquisition clause. Therefore, it'll have the old value of the variable, not the new one.

When you are dealing with an assignment to an already declared variable, you are using this form of the using statement. The fact that you are assigning a value to a variable like

using ( x = something )

is irrelevant. The whole x = something is treated as an expression and only the value of that expression is what matters. It's important to know that "resource variable" is not "x" here. It's an invisible variable. From the compiler's perspective, there's not much difference between the following constructs:

using ( something ) 
using ( x = something )
using ( y = x = something )

In all cases, the expression will get executed and the value is what will get guaranteed disposal, not the variable. What would the compiler supposed to do if this wasn't the defined behavior and you had written the third line in the above block? Dispose x? y? both? neither? The current behavior makes sense.