Question

I have a question about exception handling.

To prevent the “[YourProgram] has stopped working” Windows dialog, I usually catch even unhandled exceptions this way:

In App.xaml.cs:

    protected override void OnStartup(StartupEventArgs e)
    {
        Application.Current.DispatcherUnhandledException += ProcessDispatcherException;
        AppDomain.CurrentDomain.UnhandledException += ProcessUnhandledException;
        // Blah blah blah... Performs a lot of loading operations...
        mainWindow.Show();
    }

and then

    private void ProcessUnhandledException(object o, UnhandledExceptionEventArgs e)
    {
        logException("An unhandled exception has been thrown\n"+(e.ExceptionObject as Exception).ToString(), e.ExceptionObject as Exception);
        Application.Current.Shutdown();
    }

Okay, I don’t have the Windows dialog. Now ideally I’d like to prevent this force closing scenario. The application I’m developing here has a startup time which lasts around 1 minute for the lightest users (most of them need to wait 2 or 3 minutes for launching it, it has to load a very large and complex data referential), so restarting it can cause trouble

I’d like to know about your “best practices” for this case. I am thinking about just re-creating a new window in the handler and re-show it anyway, so only the UI will be reinitialized to startup state, no other referential will be loaded, 2 – 3 minutes saved. Any other advices?

Oh and of course, this is the “extreme emergency case which should not be reached”, but unfortunately it is, mostly due to our dependencies to other systems managed by other branches of the company with who I don’t have any control or right to complain (yes, international companies can suck sometime), and it is not try/catchable in code 🙁

Thanks!

Answer 1

I am assuming from what you are writing that you want your application to be mission critical, meaning, if anything occurs that makes it fail, it needs to be restarted automatically.

The best way to accomplish this is to create a second watchdog process that will restart your application anytime it fails. You can then allow your application to quietly terminate itself when there is an unhandled exception, cleaning up whatever you can in your unhandled exception processor.

The simplest way to implement a watchdog like this is to have a no-window process (e.g., a console app) with a background thread loop that periodically checks that your application is running by checking if a wait handle is locked. Something like this:

// Declared in class
object checkLocker = new object();
bool mtStopCheck = false;

// Thread loop
bool stopCheck = false;
while (stopCheck == false)
{
    if (wait_handle_is_unlocked)
        restart_application();
    Thread.Sleep(1000);

    lock (checkLocker)
    {
        stopCheck = mtStopCheck;
    }
}

When you want to shut the watchdog down another thread does this:

// Stop the watchdog thread so the watchdog app can shut down
lock (checkLocker)
{
    mtStopCheck = true;
}

Since you’d be running in the same terminal session you don’t need a global wait handle so no privilege issues on Vista/Windows 7.

If the user closes the application and you don’t want it running again, you can send a signal to the watchdog process (e.g., with named pipes, or use a second kind of wait handle that you lock when you want the watchdog to suspend or shut down) that the app has been shut down and should not be restarted.

You can launch your watchdog in the startup folder or some other automatic method, or, you can have your app launch it the first time it runs.