[...]
So it's not like the form isn't going to be disposed - unless an
exception is thrown between construction and the method call.
I'm beginning to suspect that the Form is finalized, not disposed,
if an exception is thrown anywhere in the message loop.
I haven't looked at the Application.Run() method via Reflector (or any
other for that matter
), but given the documentation, it seems
reasonable to believe that it deals with disposing of form instances
even in the exceptional case.
I know that exceptions are dealt with differently in the GUI thread
than in other threads. They must be because there's the
ThreadException event that you can subscribe to, and if there's a
handler for that event, GUI thread exceptions that occur during the
dispatch of window messages are simply reported and don't cause the
application to exit.
It seems plausible (you could check this in Reflector, I guess
)
that when the event is _not_ handle, the way the application exits is
either through rethrowing the exception (in which case a "using" or
try/catch/finally block in the Run() method or something it calls
would close and/or dispose the form), or by explicitly closing all
open forms (which would obviously dispose the form).
And even if not, since the project wizard outputs code that will
simply exit the application once the Run() method returns, it's
difficult to see why the form should be required to be disposed at
that point anyway. Personally, I am generally in the habit of
cleaning resources up before exiting. However, there's a good
argument in favor of just not bothering...the OS will clean them up
when the process exits anyway, and it just delays the exit of your
process to clean stuff up that is in use.
Tracing through the
relevant framework code in Reflector isn't going very well, there's a
lot of
it.
Maybe the exception is being thrown from the constructor after all,
in which
case a containing using block won't help.
Isn't it a requirement that if the constructor throws an exception,
any unmanaged resources in the class are to be disposed of by the
class itself?
