StreamReader/StreamWriter

Question

Hello everyone,

I understand there is no need to call Dispose explicitly when dealing with StreamReader/StreamWriter object instances since GC will take care of it in Finalizer method.

My question is, I want to know the benefits and potential issues of using "using" statement to deal with StreamReader/StreamWriter.

thanks in advance,
George

George George · Answer

Thanks for clarification. :-) regards, George

Ryan Alford · Answer

I put everything inside of a Try/Catch. just company programming practices.

George George · Answer

Hi Ryan, Good to see you participation. Could you explain your reasons why put using block inside try/catch please? :-) regards, George

Ryan Alford · Answer

Neither way will release the resources faster. Since the GC is what really frees up the resources, you will have to wait for the GC to release the resources. So it doesn't really matter which way you do it. personally, I put the resource in a using block which is inside a try/catch..... ie: try { using(.....) { } } catch { } I haven't had anybody complain about performance yet.

George George · Answer

Thanks, so your point is put resource is using block will enable it to be reclaimed more quickly? Is that what you mean? regards, George

zol · Answer

Right when the control leaves the using block, the memory that was referenced by these objects can be cleaned up for use. And as you said, it doesn't require an explicit close method call which makes them i think so nice to use them.

George George · Answer

Thanks Dave, Question answered. regards, George

Dave · Answer

Almost. If you are not concerned about an exception being thrown by the two operations in the finally part i.e. sr.Close(); sr.Dispose(); then you only need the one try/catch. If you want to catch any exception at all thrown in a using block, then that has to be nested in a try/catch. And, as discussed, that results in two try/catches. So, in the final round up, if you are concerned about a possible exception in the finally part of a try/catch, then you would need to nest that try/catch and it would be the exact same as if you nested a using . So it all comes down to whether you are happy that an exception is unlikely to be thrown in the finally block. That might be something you want to research. I have no idea what the likelihood of exceptions being thrown due to those two operations are. Closing the database connection could conceivably run into problems from time to time. Perhaps someone with more experience than me could answer that. At this stage, I am only a student.

George George · Answer

Thanks Dave, I agree with you. Since the discussion is lengthy, I want to finally confirm with you that to achieve the same effect, you only need 2 try-catch block and using block needs 3 try-catch blocks. So, your code is more efficient. Correct? regards, George

Dave · Answer

I maintain that my way is more efficient. Basically, the only difference is that I am calling Dispose() manually. I re-iterate, you need to nest the using block in a try/catch to catch any exceptions thrown in that block. This is inefficient, if the alternative is using just the one try/catch. try/catch comes with a lot of overhead.

George George · Answer

Thanks Bechir, 1. You mentioned "if you dispose this object by forcing the GC to clean it then after this line u make use of it by carelessness u will recieve a null reference exception". What do you mean "forcing the GC to clean it"? Invoking GC.Collect explicitly or you mean call Dispose method? 2. "to avoid this problem" -- because of the lifetime of the variable in the using block does not expand beyond the using block? regards, George

Bechir Bejaoui · Answer

No I mean if you define an object an then use it in a given block if the given object belongs to the managed code and implements the IDisposable interface if you dispose this object by forcing the GC to clean it then after this line u make use of it by carelessness u will recieve a null reference exception so it is better to use using(object){}to avoid this problem an to avoid using try{}catch(){}block and also as you say try{} Finally{object.dispose();}, the first alternative is the simpliest and the most safe by the way if you take a look on the generated CIL according to the using alternative it does expand to try/final logic try it

George George · Answer

Hi Bechir, You mean using block only catches NullreferenceException? It should catch no exception and just do a finally block execution no matter what happens (normally or exception thrown) in the using block. Any comments? regards, George

Bechir Bejaoui · Answer

using keyword is used within object whose implement the Dispose method. It is particulary used to initiate the GC to destroy an object just when it is no more useful in a given scope. it is possibly used instead of try{//to do deal with an object }catch(NullreferenceException caught){}block

George George · Answer

Thanks Dave, Your reply is really great! Two more comments, 1. You mentioned below, -------------------- it will actually catch an exception catch { ...handle exceptions } -------------------- I think you mean your code only catch a specific exception, but actually you are using catch clause and no exception type is assigned with catch -- it means catch all exceptions, not one specific type of exception. So, your code is the same as the code generated by using block. 2. "need an outer try/catch statement" -- I agree with this solution. But I think it is of the same effect of using try/catch block inside the finally block to wrap the statement like Dispose. Any comments? regards, George

Dave · Answer

Regarding your first query, I will try and explain using an anecdote. When I first discovered the using keyword, I included in an application which had a lot of database interactions. An example of the code: using(IDBConnection conn = new SQLiteDBConnection ()) { …connect and do stuff …exception was thrown here } An exception was being thrown in one case due to a dodgy SQL statement. This was within the using block. But nothing was catching the exception. So, even though there was a try catch statement hidden by using, it wasn't catching anything. I then discovered that I had to embed the whole using block in a try/catch, if I wanted to catch that exception. So, to answer your question, a using block doesn't actually catch anything. All it is good for his closing and disposing of whatever object you are using (whether it is a database connection or an input stream). My code is only more efficient insofar as it will actually catch an exception. try { IDBConnection conn = new SQLiteDBConnection (); …any exceptions will be thrown here } catch { ...handle exceptions } finally { conn.Close(); conn.Dispose(); } However, it won't catch an exception thrown by any code in the finally part. That being the case, if you were worried about an exception being thrown in the "clean up" operations which are normally put in the finally block, then you should use an outer try catch. With my way, you have a little more control over things and you can catch the lions share of exceptions with just the one try/catch. With a using block, to catch any exceptions at all, you need an outer try/catch statement. And that means a minimum of two try/catch blocks, rather than the single one that I use. I hope this helps.

George George · Answer

Thanks, 1. From your reply, I learned two things which is really valuable. - using block does not handle any exception in finally, e.g. Dispose/Close - using block will catch all exception and not thrown again? My understanding correct? 2. I understand why you say using try-catch block together with using block is less efficient. But what is your code to be more efficient than using block? Could you show here please? regards, George

Dave · Answer

Basically, as far as I can see, the using keyword is useful if you think you might forget to close the stream. Otherwise, here is my analysis of it: Now, although a try/catch is hidden by the using structure, you still need to embed it in another try/catch to catch the exception. For example: try { using(sr = new StreamReader()) { do stuff… } catch { handle exception } This is equivalent to: try { try { srObject.Open() ... read stuff etc... } catch { any exceptions ... } finally { srObject.close() srObject.dispose() } catch { handle exception... } As you can see, you are now using two try/catches instead of just the one. That is why I just use the one try/catch. Same result, less overhead. And usually, I am not concerned about an exception being thrown by the Close() or Dispose() operations. Having said all that, if you want to be extra cautious and guard against an exception being thrown by the actual closing of the stream (sw.Close()), then the outer try/catch is a worthwhile precaution. Exception handling is just another cost/benefit decision a programmer has to make. It adds stability, but also overhead. So I guess it is a decision to be made on the case by case basis.

George George · Answer

Great Dave! 1. Good point! I understand C# compiler will expand code of using block to catch and finally. I am interested to learn that what types of exception in the expanded code of using block will catch? All types of exceptions or some specific exception types (e.g. IO or Stream class related)? 2. Any differences between your code and C# compiler expanded code for using block? I think they are the same, why do you think your code is of better performance? regards, George

George George · Answer

Great Scott! I have a further question. If there is exception, and in both exception handler and finally block, I do not call Close/Dispose explicitly, will Dispose/Close be called automatically during exception (e.g. similar to during stack unwinding in C++)? Or we have to wait for GC to call Finalize? regards, George

Dave · Answer

Personally, I don't like using . It hides a try/catch which you cannot even use to catch anything without nesting it in another try/catch. Try/catches are expensive from a processing perspective. So, rather than using , I just use the one try/catch: try { srObject.Open() ... read stuff etc... } catch { any exceptions ... } finally { srObject.close() srObject.dispose() } You can catch the exceptions with just the one try/catch doing it that way.

Scott Lysle · Answer

Using defines the scope of the object; once you depart from the using statement; its resources are submitted for cleanup; as such, it may be that the resources are cleaned up sooner but than they would be given normal garbage collection.