‘using’ statement vs ‘try finally’

by

From MSDN, using Statement (C# Reference)

The using statement ensures that Dispose is called even if an exception occurs while you are calling methods on the object. You can achieve the same result by putting the object inside a try block and then calling Dispose in a finally block; in fact, this is how the using statement is translated by the compiler. The code example earlier expands to the following code at compile time (note the extra curly braces to create the limited scope for the object):

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

So basically, it is the same code but with a nice automatic null-checks and an extra scope for your variable. The documentation also states that it “ensures the correct use of IDisposable object” so you might as well gets even better framework support for any obscure cases in the future.

So go with option 2.

Having the variable inside a scope that ends immediately after it’s no longer needed is also a plus.

More Related Contents:

  1. What’s wrong with using Thread.Abort()
  2. How can I set processor affinity to a thread or a Task in .NET?
  3. How to pass parameters to ThreadStart method in Thread?
  4. Is there a way to indefinitely pause a thread?
  5. Task continuation on UI thread
  6. Why we need Thread.MemoryBarrier()?
  7. How to invoke a UI method from another thread
  8. Does a locked object stay locked if an exception occurs inside it?
  9. Async/Await vs Threads
  10. What happens if i return before the end of using statement? Will the dispose be called?
  11. Benefits of using async and await keywords
  12. A reproducible example of volatile usage
  13. Do I need to lock or mark as volatile when accessing a simple boolean flag in C#?
  14. thread with multiple parameters
  15. Event handlers not thread safe? [duplicate]
  16. Difference between lock(locker) and lock(variable_which_I_am_using)
  17. What is the difference between ManualResetEvent and AutoResetEvent in .NET?
  18. Lock (Monitor) internal implementation in .NET
  19. .NET 4.0 and the dreaded OnUserPreferenceChanged Hang
  20. Advantage of using Thread.Start vs QueueUserWorkItem
  21. How do I spawn threads on different CPU cores?
  22. Reading an int that’s updated by Interlocked on other threads
  23. How to get awaitable Thread.Sleep?
  24. Thread parameters being changed
  25. Queue of async tasks with throttling which supports muti-threading
  26. Parallel doesnt work with Entity Framework
  27. ThreadStaticAttribute in ASP.NET
  28. Handling events from out-of-proc COM server in managed STA application
  29. Async and Await with For Loop [duplicate]
  30. Calling an async method from a synchronous method

Leave a Comment