No. The compiler will generate a separate finally block for each variable. The spec (ยง8.13) says: When a resource-acquisition takes the form of a local-variable-declaration, it is possible to acquire multiple resources of a given type. A using statement of the form using (ResourceType r1 = e1, r2 = e2, …, rN = eN) statement … Read more
Similar as using (…) uses IDisposable to clean up resources, await using (…) uses IAsyncDisposable. This allows to perform also time-consuming tasks (e.g involving I/O) on cleanup without blocking.
It’s perfectly safe to call return inside your using block, since a using block is just a try/finally block. In your example above after return true, the scope will get disposed and the value returned. return false, and scope.Complete() will not get called. Dispose however will be called regardless since it reside inside the finally … Read more
Since you have a using block, the Dispose method of the SQLCommand will be called and it will close the connection: // System.Data.SqlClient.SqlConnection.Dispose disassemble protected override void Dispose(bool disposing) { if (disposing) { this._userConnectionOptions = null; this._poolGroup = null; this.Close(); } this.DisposeMe(disposing); base.Dispose(disposing); }
No, I think it’s clearer this way. Don’t worry, Dispose will still be called “on the way out” – and only after the return value is fully evaluated. If an exception is thrown at any point (including evaluating the return value) Dispose will still be called too. While you certainly could take the longer route, … Read more
There are a few reasons you’d want to take them out. It’s pointless. They add no value. It’s confusing. What is being used from that namespace? If you don’t, then you’ll gradually accumulate pointless using statements as your code changes over time. Static analysis is slower. Code compilation is slower. On the other hand, there … Read more
An unused using has no impact to the runtime performance of your application. It can affect the performance of the IDE and the overall compilation phase. The reason why is that it creates an additional namespace in which name resolution must occur. However these tend to be minor and shouldn’t have a noticeable impact on … Read more
Yes Yes. Either way, when the using block is exited (either by successful completion or by error) it is closed. Although I think it would be better to organize like this because it’s a lot easier to see what is going to happen, even for the new maintenance programmer who will support it later: using … Read more
It appears the syntax has slightly changed since those blog posts were written. As the error message suggests, add static to your include statement: using static System.Console; // ^ class Program { static void Main() { WriteLine(“Hello world!”); WriteLine(“Another message”); } } Then, your code will compile. Note that, in C# 6.0, this will only … Read more
Yes, Dispose() is only called on non-null objects: http://msdn.microsoft.com/en-us/library/yh598w02.aspx