Don’t dispose of objects that you don’t own

re: Don’t dispose of objects that you don’t own

Joe Albahari — Fri, 26 Jun 2009 06:15:36 GMT

Shouldn't EnsureInitialized be overloaded to provide this disposal behaviour as an option?

If you make this an option, it will yield greater benefit than just convenience. When people see the disposeUnusedObject parameter in IntelliSense, they'll be forced to think about the problem - which is surely a good thing!

Otherwise, all but the most astute people will be unaware that the problem exists and will leave undisposed objects at the mercy of the GC's schedule. Which is OK with wait handles (which have a low OS burden), but not so cool with file handles (which can block access to the file!)

re: Don’t dispose of objects that you don’t own

Kristian Freed — Fri, 26 Jun 2009 12:14:13 GMT

Nice posting!

I think ownership of objects is something people spend much too little time thinking about (and documenting!) when it comes to garbage collected languages in general. In C++ for example, you need to be explicitly aware of who owns an object much more often, because someone is responsible for deallocating it at some point. Removing the need to explicitly free objects from memory also gives the illusion that all other questions of ownership (May I change this object I received from somewhere else, or do I have to make a copy? Can it change while I'm using it? May/should I dispose of it when I'm done with it myself?) have been resolved automatically as well.

re: Don’t dispose of objects that you don’t own

phillips.joshua — Fri, 26 Jun 2009 18:17:35 GMT

Hi Joe,

Ideally, yes. This is exactly what we had hoped to do. Unfortunately, the harsh reality of shipping a product is that sometime you have to, well, ship.. And to do that, we have to stop churning code at some point. Given that this API is really advanced and we don't expect many mainstream developers to use it (they'd use Lazy<T> instead) we decided not to prioritize adding an overload. Those that will use it, are likely to be very concerned with things like file handles and make sure they're disposed properly.

Thanks!

Josh

re: Don’t dispose of objects that you don’t own

Tom Kirby-Green — Fri, 26 Jun 2009 18:34:32 GMT

I would concur with Kristian's point, a lot of developers seems to mentally broaden the GC's remit from 'memory' to 'general responsibility' collector. Gosh how I wish I could declare a const reference to a object in C# ...

re: Don’t dispose of objects that you don’t own

Nicholas Paldino [.NET/C# MVP] — Thu, 02 Jul 2009 19:21:04 GMT

Shouldn't the call to compare be to ReferenceEquals on Object? If for some reason, compare-by-value semantics has been implemented in the equality operator (which best practice indicates you should implement != as well), then there is an issue of disposing the wrong object here.

re: Don’t dispose of objects that you don’t own

phillips.joshua — Tue, 07 Jul 2009 04:12:35 GMT

Hi Nicholas,

Good question. In most cases, that would be true, but in this case, the restrictions on generics actually helps(?) out here.

In C# overloading operators on generic types is not supported and thus inside of the generic method, != will not resolve to the overriden implementation. You do have a good argument for readability, however!

Josh

re: Don’t dispose of objects that you don’t own

Duarte Nunes — Thu, 06 Aug 2009 18:55:50 GMT

Hi,

Indeed, object ownership is an issue with the disposable pattern, which is why the right thing to do is indeed to let the user deal with object disposal (or provide an explicit overload).

Also, I was looking at the beta 1 code for LazyInitializer and noticed that you use an acquire barrier on the public methods, but I can't seem to figure out what it's for, with my understanding of the memory model (is there going to be a formal memory model specification, based on Prism?).

Thanks!

Duarte

re: Don’t dispose of objects that you don’t own

phillips.joshua — Thu, 06 Aug 2009 21:56:28 GMT

Hi Duarte,

We read a dummy volatile variable to prevent potential memory reordering in IA64.

Thanks!

Josh

re: Don’t dispose of objects that you don’t own

Duarte Nunes — Thu, 06 Aug 2009 22:26:42 GMT

Hi Josh,

Thanks for the answer! I guess you mean the potential load-load reordering. Does this mean the memory model for 4.0 that we developers must address is the weakest (i.e., IA64's)?

Thanks again,

Duarte

re: Don’t dispose of objects that you don’t own

phillips.joshua — Thu, 06 Aug 2009 22:33:15 GMT

That, of course, depends on the architecture(s) you are targeting. :)

Josh