foreach (ManagementObject result in results) using(result) { //code here } It’s not normally good practice to assign the variable outside the using block because the resource would be disposed but could stay in scope. It would, however, result in clearer code here because you can nested the using statement against the foreach. EDIT: As pointed … Read more
When you return an IDisposable from a method, you are relegating the responsibility of disposing it to your caller. Thus, you need to declare your using block around the entire usage of the stream, which in your case presumably spans the UploadFile call. using (var s = GetFileStream()) UploadFile(s);
This mechanism is normally used in templated code, i.e. template <typename Value> class Foo. Now the question is which swap to use. std::swap<Value> will work, but it might not be ideal. There’s a good chance that there’s a better overload of swap for type Value, but in which namespace would that be? It’s almost certainly … Read more
The fact that you need to ensure that the object is disposed indicates a design flaw. It’s fine if disposing is the polite or efficient thing to do, but it should not be semantically necessary. There is no way to enforce that an object is disposed of via the using statement. However, what you can … Read more
No, it’s not. using ensures that Dispose() will be called, which in turn calls the Close() method. You can assume that all kinds of Streams are getting closed by the using statement. From MSDN: When you use an object that accesses unmanaged resources, such as a StreamWriter, a good practice is to create the instance … Read more
From The C# Team’s answers to frequently asked questions: When you add assembly references or make use of the ‘using’ keyword, csc.exe will ignore any assembly which you have not actually made use of in your code … Don’t [waste] your time stripping out unused ‘using‘ statements or assembly references from your application. The C# … Read more
As soon as you leave the using block’s scope, the stream is closed and disposed. The Close() calls the Flush(), so you should not need to call it manually.
Yes, it will; the implementation of DbConnection.Dispose() calls Close() (and so do its derived implementations).
When you see a using statement, think of this code: StreadReader rdr = null; try { rdr = File.OpenText(“file.txt”); //do stuff } finally { if (rdr != null) rdr.Dispose(); } So the real answer is that it doesn’t do anything with the exception thrown in the body of the using block. It doesn’t handle it … Read more
Unfortunately, the using directive does not do what you want. You can say: using Frob = System.String; and using ListOfInts = System.Collections.Generic.List<System.Int32>; but you cannot say using Blob<T> = System.Collections.Generic.List<T> or using Blob = System.Collections.Generic.List It’s a shortcoming of the language that has never been rectified.