Using "using" statement to dispose

Question

Does this make sense ?

Having a simple class

   class Test
   {
     public Test()
     {
        // Do whatever
     }
   }

and then instantiating it

using(new Test())
{
  // Nothing in here
}

The using statement is there just to make sure Test is disposed. When will it be disposed if I just call

new Test()

Answer 1

Test isn't IDisposable, so that won't even compile. But if it was disposable, yes using will do it, and new by itself won't. It is an unusual usage, but I've seen similar. Rarely.

Based on your comment (main question), I suspect that you are confusing garbage collection and disposal. There is no way to forcibly make something get collected, short of GC (which you should not do). Unless you have a really good reason to want it collected, just let it be - chances are it is "generation 0" and will be collected cheaply anyway.

Also, the "do whatever" suggests doing something in a constructor but not caring about the created object; a static method would be preferable:

public class Test { /* could be static */
     public static void DoSomething() { ... }
}
...
Test.DoSomething();

Answer 2

By not assigning the instance to a variable, it will be eligible for GC as soon as it goes out of scope.

Or, is there something else you are trying to accomplish with this?

Answer 3

Recommended reading:

http://msdn.microsoft.com/en-us/magazine/bb985010.aspx

Answer 4

I suspect your Test class is of IDisposable type and that you've neglected to show it in your sample?

If you do not call Dispose in your finalizer, Dispose() will never get called (but the object would still be freed).

Try this instead:

public class Test : IDisposable
{
    public void Dispose()
    {
        Console.WriteLn("Dispose");
    }

    ~Test()
    {
        Dispose();
    }
}

Using the above example, if you don't explicitly call Dispose, the finalizer (d'tor) would still be called when the object is garbage collected (freed), hence calling Dispose().

Note the distinction between Finalizer (d'tor) and Dispose(). The gc doesn't know about IDisposable, hence it's up to you to call Dispose() in your finalizer. Also, to help the gc determine if there's a need to Finalize the object prior to 'freeing' it, you'd want to call GC.SuppressFinalize(this) in your Dispose method. For example, if you're calling Dispose() explicitly or implicitly by using "using", then the gc can skip finalizing the object again which only repeats a call to Dispose().