In .Net does "using" do what we're led to believe it does?

Question

I was reading a forum recently, and saw this comment:

So, you see you've been duped into believing that the 'using' syntax is going to help clean up your resources for you. Oh well, welcome to .NET development.

This has really freaked me out! I use using almost exclusively over .Dispose() in nearly all cases (streams especially). Is there some weird thing with "using" that no one has told me? Is it good or bad or indifferent to use?

Answer 1

From MSDN:

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

is translated into the following by the compiler:

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

so not sure what you're worrying about.

Edit: Be warned though, if you are using the using pattern on your own types, the pattern will only be as effective as your Dispose() method. Some of the comments and other answers this.

Answer 2

There are some cases where using will not clean up as you might expect, such as:

using (var myObject = new DisposableObject().AnotherDisposable())
{
    //Do things to myObject
}

In this example you have two objects, DisposableObject and AnotherDisposable and the using will only clean up AnotherDisposable and leave DisposableObject leaking.

Answer 3

It would help if you could provide us with a link to the context; but, generally, that kind of mostly-attitude opinion without backup should be taken with a healthy grain of salt.

Answer 4

Yes, it does do what you'd expect it to do. If you have a look at the IL of a "using" statement this is what you get:

L_0007: newobj instance void Demo.SomeClass::.ctor()
L_000c: stloc.0 
L_000d: nop 
...
L_0040: nop 
L_0041: nop 
L_0042: leave.s L_0054
L_0044: ldloc.0 
L_0045: ldnull 
L_0046: ceq 
L_0048: stloc.2 
L_0049: ldloc.2 
L_004a: brtrue.s L_0053
L_004c: ldloc.0 
L_004d: callvirt instance void [mscorlib]System.IDisposable::Dispose()

(I stipped out the stuff from within my using statement to condense a bit, but you get the idea)

Answer 5

'Using' is a pattern. Sometimes your code flows with the pattern and sometimes it doesn't. Meaning that sometimes you have to actually call dispose because your object doesn't fit the 'using' pattern's scope.

As an example, if you instance an object upon application startup and then need to dispose of it in the middle of the application and instance a new one, chances are you can't use 'using.'

Answer 6

It will clean up any resources that the Dispose() method cleans up, because the using(){} construct is just syntactic sugar for calling the Dispose() method.

Answer 7

I take it you mean this thread? (thank you google):
http://social.msdn.microsoft.com/Forums/en-US/netfxbcl/thread/4b63dc82-c7c0-4495-97ca-d92502a33d15

The using statement will call .Dispose() on any object that implements IDisposable. If the using statement failed to clean up the resources, a call to Dispose() directly would have failed as well. In the specific case that I linked to, it sounds like a mis-behaving virus checker was the problem.

Answer 8

Using is just another way of ensuring the Dispose method is called on your object. As far as any resources not handled by the Dispose method, they will remain for garbage collection so you are still at the mercy of the object you declare in your using statement. I am obviously reading into your comment since you did not post a link to the article you are referring to.

Answer 9

The end of the using block calls Dispose. Dispose provides the opportunity for the caller to explicitly free unmanaged resources that your object is using. The garbage collector will implicitly free managed resources using the object's Finalizer. But the GC knows nothing about unmanaged resources that you have allocated (file handles, window handles). So, if you allocate unmanaged resources and don't free them properly in your Dispose correctly, you will leak. Using is only as good as your Dispose.

There's much more on garbage collection here and more on Finalize v.s. Dispose in this SO thread.

Answer 10

I have seen times where a file was still left open when the application crashed because the using construct was used. It seems that closing connections is not always done when using this. So, when I open files or database connections I explicitly use the try..finally myself.