Rolling your own message loop, any pitfalls?

Question

This question is slightly related to this question about exception handling. The workaround I found there consists of rolling my own message loop.

So my Main method now looks basically like this:

[STAThread]
static void Main() {
  // this is needed so there'll actually an exception be thrown by
  // Application.Run/Application.DoEvents, instead of the ThreadException
  // event being raised.
  Application.SetUnhandledExceptionMode(UnhandledExceptionMode.ThrowException);

  Application.EnableVisualStyles();
  Application.SetCompatibleTextRenderingDefault(false);

  Form form = new MainForm();
  form.Show();

  // the loop is here to keep app running if non-fatal exception is caught.
  do {
    try {
      Application.DoEvents();
      Thread.Sleep(100);
    }
    catch (Exception ex) {
      ExceptionHandler.ConsumeException(ex);
    }
  }
  while (!form.IsDisposed);
}

What I'm wondering though, is this a safe/decent way to replace the more typical 'Application.Run(new MainForm());', whether it's used for exception handling or for whatever else, or should I always stick to using Application.Run?

On another app that's in testing now a similar approach is used for both loading (splashscreen) and exception handling, and I don't think it has caused any troubles (yet :-))

Answer 1

Pitfall 1:

Thread.Sleep(100);

Never. Use WaitMessage().

Otherwise, it is possible roll out your own message loop, but in your scenario it seems somewhat pointless.

You may also want to examine Application.Run() code (with .Net Reflector, for instance).

Answer 2

Yes... I think some components wont work with that code. Some of them require to live in a thread that has an Application.Run in it to effectively pick up their messages.

Answer 3

If you want to customize message processing, consider implementing IMessageFilter, then call Application.AddMessageFilter to tell the standard message pump to call your filter function.