using-statement

I have a code block as follows and I'm using 3 nested using blocks. I found that using try finally blocks I can avoid this but if there are more than two using statements, what is the best approach? private FileStream fileStream = null; private Document document = null; private PdfWriter pdfWriter = null; using (fileStream = new FileStream("ABC.pdf", FileMode.Create)) { using (document = new Document(PageSize.A4, marginLeft, marginRight, marginTop, marginBottom)) { using (pdfWriter = PdfWriter.GetInstance(document, fileStream)) { document.AddAuthor(metaInformation["author"]); document

I have two questions. 1) Should you always use a using statement on a connection? So, I would use it on the connection and then another one on a reader within the connection? So I would be using two using statements. 2) Lets say you use the using statement on the connection and also a reader being returned on the connection. So you have two using statements. Does it create two Try{}Finally{} blocks or just one? Thanks! You should always use a using statement when an object implements IDisposable . This includes connections. It will create two nested try{}finally{} blocks. Be careful here. You

HttpWebReponse implements IDisposable interface, but why is there no Dispose method. It only contains Close method. Will be using pattern still available for this class? HttpWebResponse implements IDisposable interface explicitly. So you can call Dispose only when you cast HttpWebResponse to IDisposable . The Close method of HttpWebResponse calls Dispose internally. HttpWebResponse response = // assigned from somewhere IDisposable disposableResponse = response as IDisposable; disposableResponse.Dispose(); Since HttpWebResponse implements IDisposable you can use it with an using-statement.

This question already has an answer here: returning in the middle of a using block 7 answers Which way is better practice: return a value from a method inside an using statement or declare a variable before, set it inside and return it after? public int Foo() { using(..) { return bar; } } or public int Foo() { var b = null; using(..) { b = bar; } return b; } I prefer the first example. Fewer variables, fewer lines of code, easier to follow, easier to maintain... public int Foo() { using(..) { return bar; } } Following the "less is more" principle (really just a variant of KISS ), the former.