What happens if i return before the end of using statement? Will the dispose be called?

by

Yes, Dispose will be called. It’s called as soon as the execution leaves the scope of the using block, regardless of what means it took to leave the block, be it the end of execution of the block, a return statement, or an exception.

As @Noldorin correctly points out, using a using block in code gets compiled into try/finally, with Dispose being called in the finally block. For example the following code:

using(MemoryStream ms = new MemoryStream())
{
     //code
     return 0;
}

effectively becomes:

MemoryStream ms = new MemoryStream();
try
{
    // code
    return 0;
}
finally
{
    ms.Dispose();
}

So, because finally is guaranteed to execute after the try block has finished execution, regardless of its execution path, Dispose is guaranteed to be called, no matter what.

For more information, see this MSDN article.

Addendum:
Just a little caveat to add: because Dispose is guaranteed to be called, it’s almost always a good idea to ensure that Dispose never throws an exception when you implement IDisposable. Unfortunately, there are some classes in the core library that do throw in certain circumstances when Dispose is called — I’m looking at you, WCF Service Reference / Client Proxy! — and when that happens it can be very difficult to track down the original exception if Dispose was called during an exception stack unwind, since the original exception gets swallowed in favor of the new exception generated by the Dispose call. It can be maddeningly frustrating. Or is that frustratingly maddening? One of the two. Maybe both.

More Related Contents:

  1. Dispose, when is it called?
  2. returning in the middle of a using block
  3. Do I need to Dispose a SemaphoreSlim?
  4. Who Disposes of an IDisposable public property?
  5. What is the C# Using block and why should I use it? [duplicate]
  6. Use of Finalize/Dispose method in C#
  7. Do you need to dispose of objects and set them to null?
  8. Is it considered acceptable to not call Dispose() on a TPL Task object?
  9. ‘using’ statement vs ‘try finally’
  10. What is the difference between using IDisposable vs a destructor in C#?
  11. Disposing WPF User Controls
  12. Using statement vs. IDisposable.Dispose()
  13. Should you implement IDisposable.Dispose() so that it never throws?
  14. Proper way to dispose a new Form
  15. Should IDisposable.Dispose() be made safe to call multiple times?
  16. Difference between destructor, dispose and finalize method
  17. Is IDisposable.Dispose() called automatically? [duplicate]
  18. Implementing IDisposable on a subclass when the parent also implements IDisposable
  19. What does Process.Dispose() actually do?
  20. What is IDisposable for?
  21. When should I use GC.SuppressFinalize()?
  22. Who should call Dispose on IDisposable objects when passed into another object?
  23. When is “using” block used for in C#? How to use “using” block in C#?
  24. Should I always disconnect event handlers in the Dispose method?
  25. When or if to Dispose HttpResponseMessage when calling ReadAsStreamAsync?
  26. Guidelines For Dispose() and Ninject
  27. When should I use the using Statement? [duplicate]
  28. using statement FileStream and / or StreamReader – Visual Studio 2012 Warnings
  29. Determining if IDisposable should extend an interface or be implemented on a class implementing said interface
  30. Is it necessary to dispose System.Timers.Timer if you use one in your application?

Leave a Comment