Question

I’d like to know when i should and shouldn’t be wrapping things in a USING block.

From what I understand, the compiler translates it into a try/finally, where the finally calls Dispose() on the object.

I always use a USING around database connections and file access, but its more out of habit rather than a 100% understanding. I know you should explicity (or with a using) Dispose() objects which control resources, to ensure they are released instantly rather than whenever the CLR feels like it, but thats where my understanding breaks down.

Are IDisposables not disposed of when they go out of scope?

Do I only need to use a USING when my object makes use of Dispose to tidy itself up?

Thanks

Edit: I know there are a couple of other posts on the USING keyword, but I’m more interested in answers relating the the CLR and exactly whats going on internally

Andrew

Answer 1

No, IDisposable items are not disposed when they go out of scope. It is for precisely this reason that we need IDisposable – for deterministic cleanup.

They will eventually get garbage collected, and if there is a finalizer it will (maybe) be called – but that could be a long time in the future (not good for connection pools etc). Garbage collection is dependent on memory pressure – if nothing wants extra memory, there is no need to run a GC cycle.

Interestingly (perhaps) there are some cases where ‘using’ is a pain – when the offending class throws an exception on Dispose() sometimes. WCF is an offender of this. I have discussed this topic (with a simple workaround) here.

Basically – if the class implements IDisposable, and you own an instance (i.e. you created it or whatever), it is your job to ensure that it gets disposed. That might mean via ‘using’, or it might mean passing it to another piece of code that assumes responsibility.

I’ve actually seen debug code of the type:

#if DEBUG     ~Foo() {         // complain loudly that smoebody forgot to dispose...     } #endif 

(where the Dispose calls GC.SuppressFinalize)