Re: Top 10 Worst C# Features

["Randy Brukardt" <randy@rrsoftware.com>]

<Stefan.Lucks@uni-weimar.de> wrote in message 
news:alpine.DEB.2.20.1509021228510.5314@debian...
...
>#2 Finaliz(ers) are fragile
>
>In Ada, the finalize procedure for an object can be called more than once,
>Finalize should rather not raise an exception, ... apparently, C#
>finalzisers suffer from similar problems: "any time a finalizer runs, you
>could argue that the program either has a bug or is in a dangerous state,
>such as being shut down unexpectedly via a thread abort".

Based on the article, the situation in Ada is far less bad than the C# one. 
His description of C++ finalizers apply to Ada's as well: "[they] run 
deterministically, run on the current thread, and never run on partially 
constructed objects."
Moreover, they always run when objects are destroyed, while apparently in C# 
they don't run for explicit calls to Dispose.

Ada's issues come from two things: extremely rare cases involving exceptions 
where a finalizer might start twice, and the fact that someone can 
explicitly call it on an object. If one has control over the entire system, 
neither of these cases need happen; a program like AdaControl can enforce 
appropriate style rules to avoid problems.

If not, it's relatively easy to make Finalize callable multiple times (you 
just need a "Valid" bit in the object, which is turned off by Finalize; if 
it's off, Finalize does nothing).

Of course, Ada gets this by not supporting garbage collection on objects 
that have non-trival finalization (such an object cannot be garbage 
collected until the finalization has run, meaning they have to exist until 
they go out of scope, meaning no useful garbage collection can happen. 
Fixing that would probably introduce more problems (although if the points 
at which garbage collection could happen were appropriately limited it would 
not be a huge issue; if this issue is ever addressed in Ada, that would have 
to be the case).

In any case, Ada's situation is nothing like the asynchronous mess he 
describes for C#. It may not be perfect, but it's a heck of a lot better 
than C#.

                                                 Randy.