Should you call close even within a Using block

Using sr As New System.IO.StreamWriter("C:\test.txt")
   sr.WriteEnd
End Using
Using sr As New System.IO.StreamReader("C:\test.txt")
   sr.ReadToEnd
End Using

This is equivalent to:

sr = New System.IO.StreamWriter("C:\test.txt")
sr.开发者_C百科WriteEnd
sr.Dispose
sr = New System.IO.StreamReader("C:\test.txt")
sr.ReadToEnd
sr.Dispose

Am I right in saying the attempt to read the file may fail if the Garbage collector had not got around to disposing the StreamWriter and closing the file. If so where is the benefit is using the Using Statement in this case. Is is better practice to use

Using sr As New System.IO.StreamWriter("C:\test.txt")
       sr.WriteEnd
sr.close()
    End Using

It is a best practice to always the Using statement because if an exception is thrown during the reading the stream might never be disposed and your application will leak a file handle. If this is a desktop application the process will probably die and release the handle but in a web application not releasing unmanaged resources such as file handles could be catastrophic.

Also you don't need to call Close on your stream if you are calling Dispose.

Remark: if you want to read the contents of a text file into a string you could directly do this instead of going through the pain of instantiating a StreamReader, reading it to the end and disposing it:

Dim data = File.ReadAllText("C:\test.txt");

No, the Garbage Collector does not dispose the object, calling Dispose does that, and the using block makes sure that happens. The object may still be in memory, but the file will have been dealt with.

If you didn't call close or dispose (either manually or by use of the using block), and the object got collected it would then be finalised (slowing up garbage collection) and that would close the file handle. But this last-chance is different to dispose.

You don't have to call close on the file within the using block, but you are free to. This may be a good idea to release the handle quickly (not often an issue with file handles, more often an issue with pooled database connections), with the using block giving you an added guarantee (it's always safe to call dispose, even if its already been called).

Actually, it is equivalent to this: The Finally blocks will guarantee the Dispose is called and everything is cleaned up in the event of an exception.

    Try
        sr = New System.IO.StreamWriter("C:\test.txt")
        sr.WriteEnd()
    Finally
        sr.Dispose()
    End Try
    Try
        sr = New System.IO.StreamReader("C:\test.txt")
        sr.ReadToEnd()
    Finally
        sr.Dispose()
    End Try

Think if you are done and don't care too much about it after, can let the dispose just happen BUT dispose may take a while, so if you need to use the file (e.g. pass to another app, move to new location, or any other use of the file), then probably should Close it explicitly

Close should release any locks, expect this will fail:

dim fn as string = "C:\temp.txt"
Using sr As New System.IO.StreamWriter(fn)
    sr.WriteLine("Junk")
    ' sr.close
End Using
system.io.file.delete(fn)

Expect the delete to throw an error, since file dispose may not yet have happened If you explicitly close (e.g. un-comment the close), then should always succeed