Handling Unhandled Exceptions Problem

Handling unhandled exceptions problem

It's because you're running it through Visual Studio in Debug mode. If you release and install your app somewhere else, nothing but your global exception handler will be processed.

How to catching Unhandled Exceptions in Console application

Register a global exception handler in your main method like this:

//Add handler to handle the exception raised by additional threads
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;

Then handle all the unhandled exception in CurrentDomain_UnhandledException method.

private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
    //Your logic here, for ex., log the exception somewhere
}

How to handle unhandled exceptions in a C# program

You can define a handler to catch all unhandled exceptions. The exact mechanism depends on the UI framework you are using.

For WinForms you can do something like

AppDomain.CurrentDomain.UnhandledException += new 
    UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

// Windows forms exceptions handler
Application.ThreadException += new 
    ThreadExceptionEventHandler(Application_ThreadException);

http://kenneththorman.blogspot.com/2010/10/windows-forms-net-handling-unhandled.html

For WPF you would do something like

<Application x:Class="UnhandledExceptionHandler.App"
    DispatcherUnhandledException="Application_DispatcherUnhandledException">
</Application>

private void Application_DispatcherUnhandledException(object sender, 
                       System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
{
    // Handle the exception
}

http://www.codeproject.com/Articles/90866/Unhandled-Exception-Handler-For-WPF-Applications

Create centralized exception handling to recover from unhandled exceptions

My question was similar to this post.

I think the answer is that there is no way to recover from an unhandled exception apart from reloading the page/application. As Günter Zöchbauer stated:

Generally exception should be handled as close as possible to the
cause when there is a way to recover.

Unhandled exception occurs after handling exception

In your handler method, you need to tell .NET that you handled the exception. Otherwise it will still kill the application. You do this by using the Handled property of the DispatcherUnhandledExceptionEventArgs object.

So if you decide that you want to continue the application despite the exception, set it to true:

private void App_DispatcherUnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
{
    e.Handled = true; //let's continue and see if anything explodes
}

That said, you should still handle exceptions where they could occur (as much as possible). Take the example you gave, which looks like a network connection problem. If you caught that exception where you create the connection, you can tell the user something more specific like "I could not connect to the database. Is your network working?" Whereas if you rely on this to catch that kind of error, you can only regurgitate the exception message, which will often not make sense to the user.

This should be used as a last-resort fail-safe. It should not replace catching exceptions throughout your code.

MVC6 - Handle unhandled exceptions and still have error page redirection

This is because the Exception page needs to have an Exception object to work with. Your code catches the exception which is then suppressed. Try rethrowing the exception like so:

try
{
    await _next.Invoke(context);
}
catch (System.Exception e)
{
    //Log the exception here...
    throw;
}

How to handle all unhandled exceptions when using Task Parallel Library?

Seems like there's no built-in way to handle this (and no answer to this question after almost 2 weeks). I already rolled out some custom code to take care of this. The solution description is pretty lengthy, so I've posted in my blog. Refer to this post if you're interested.

Update 5/7/2010: I’ve found a better way to do that, making use of task continuation. I create a class ThreadFactory that exposes the Error event which can be subscribed by a top-level handler and provides methods to start a task attached with proper continuation.

The code is posted here.

Update 4/18/2011: Post code from the blog post as per Nifle's comment.

internal class ThreadFactory
{
    public delegate void TaskError(Task task, Exception error);

    public static readonly ThreadFactory Instance = new ThreadFactory();

    private ThreadFactory() {}

    public event TaskError Error;

    public void InvokeError(Task task, Exception error)
    {
        TaskError handler = Error;
        if (handler != null) handler(task, error);
    }

    public void Start(Action action)
    {
        var task = new Task(action);
        Start(task);
    }

    public void Start(Action action, TaskCreationOptions options)
    {
        var task = new Task(action, options);
        Start(task);
    }

    private void Start(Task task)
    {
        task.ContinueWith(t => InvokeError(t, t.Exception.InnerException),
                            TaskContinuationOptions.OnlyOnFaulted |
                            TaskContinuationOptions.ExecuteSynchronously);
        task.Start();
    }
}

Catch unhandled exceptions from any thread

You can use AppDomain.UnhandledExceptionHandler to handle uncaught exception.

---

Related Topics