Preventing unhandled exceptions to stop application

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!

how can you ever be sure that just creating a new window will work? Since there is an unhandled exception, you're actually unaware of the state of the rest of the program. It might be fine, it might not. Just slamming a new window on top of it is asking for trouble. — stijn, Sep 21 '11 at 08:02
Can you show some code that can't be catched by a try catch block? I can't think of any... — Daniel Hilgarth, Sep 21 '11 at 08:03
read this: http://stackoverflow.com/questions/7152354/which-exceptions-shouldnt-i-catch/7152374#7152374 — Mohamed Abed, Sep 21 '11 at 08:59
@DanielHilgarth : That's the problem: I can't either. These exceptions are fired asynchronously by a service developed by another company branch. I don't especially agree with their way of programming (they just send non-caught exceptions if a problem happens, and I have already caught these, and can't silence the others which are supposed to bubble to the next method). The problem is that I don't have any control on what they're doing :/ — Damascus, Sep 21 '11 at 09:23

score 3 · Accepted Answer · answered Sep 21 '11 at 15:36

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.

If you need more specific info let me know. You may find the book "Concurrent Programming on Windows" (Addison Wellelsy, Author Joe Duffy) to be very valuable in efforts like this. He explains how to use all the wait handles and some excellent multithreaded info, too. — Ed Bayiates, Sep 22 '11 at 20:51

Preventing unhandled exceptions to stop application

1 Answers1