¿Cómo puedo hacer algo que capture todas las excepciones 'no controladas' en una aplicación WinForms?

Hasta ahora, acabo de poner un bloque try / catch alrededor del Application.Runen el Program.cspunto de entrada al programa. Esto detecta todas las excepciones lo suficientemente bien en el modo de depuración, pero cuando ejecuto el programa sin el modo de depuración, las excepciones ya no se manejan. Recibo el cuadro de excepción no manejado.

No quiero que pase esto. Quiero que se detecten todas las excepciones cuando se ejecuta en modo sin depuración. El programa tiene varios subprocesos y, preferiblemente, todas las excepciones de ellos quedan atrapadas por el mismo controlador; Quiero registrar excepciones en la base de datos. ¿Alguien tiene algún consejo sobre cómo hacer esto?

Eche un vistazo al ejemplo de la documentación de ThreadException :

public static void Main(string[] args)
{
   // Add the event handler for handling UI thread exceptions to the event.
    Application.ThreadException += new     
  ThreadExceptionEventHandler(ErrorHandlerForm.Form1_UIThreadException);

  // Set the unhandled exception mode to force all Windows Forms errors
  // to go through our handler.
  Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);

  // Add the event handler for handling non-UI thread exceptions to the event. 
  AppDomain.CurrentDomain.UnhandledException += new       
  UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
}

Es posible que también desee no detectar excepciones al depurar, ya que esto facilita la depuración. Es algo así como un truco, pero para eso puedes envolver el código anterior con

 if (!AppDomain.CurrentDomain.FriendlyName.EndsWith("vshost.exe")) { ... }

Para evitar la captura de excepciones al depurar.

En NET 4, ciertas excepciones ya no se detectan de forma predeterminada; tienden a ser excepciones que indican un estado corrupto (posiblemente fatal) del ejecutable, como una AccessViolationException.

Intente usar la etiqueta [HandleProcessCorruptedStateExceptions] delante de su método principal, por ejemplo

using System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptions

[HandleProcessCorruptedStateExceptions]
public static int Main()
{
    try
    {
        // Catch any exceptions leaking out of the program
        CallMainProgramLoop();
    }
    catch (Exception e) // We could be catching anything here
    {
        System.Console.WriteLine(e.Message);
        return 1;
    }
    return 0;
  } 

Puede encontrar un buen ejemplo en http://www.csharp-examples.net/catching-unhandled-exceptions/ Básicamente, cambie su main a:

static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);

        Application.ThreadException += new ThreadExceptionEventHandler(Application_ThreadException);
        Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
        AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

        Application.Run(new Form1());
    }

    static void Application_ThreadException(object sender, ThreadExceptionEventArgs e)
    {
        MessageBox.Show(e.Exception.Message, "Unhandled Thread Exception");
    }

    static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
    {
        MessageBox.Show((e.ExceptionObject as Exception).Message, "Unhandled UI Exception");
    }

Puede usar la biblioteca NBug para eso. Con una configuración mínima como esta:

NBug.Settings.Destination1 = "Type=Mail;From=me@mycompany.com;To=bugtracker@mycompany.com;SmtpServer=smtp.mycompany.com;";
AppDomain.CurrentDomain.UnhandledException += NBug.Handler.UnhandledException;
Application.ThreadException += NBug.Handler.ThreadException;

Puede comenzar a recopilar información sobre todos los errores no controlados en su aplicación, incluso cuando se implementa en los clientes. Si no desea utilizar una biblioteca de terceros, debe adjuntar a los siguientes eventos:

// These two should come before enabling visual styles or running the application
AppDomain.CurrentDomain.UnhandledException += ...
Application.ThreadException += ...
...
Application.Run(new Form1());