Comment puis-je faire quelque chose qui attrape toutes les exceptions non gérées dans une application WinForms ?

Question

Jusqu'à présent, je mettais simplement un bloc try/catch autour de l'élément Application.Run dans le Program.cs point d'entrée du programme. Cela permet d'attraper toutes les exceptions en mode débogage, mais lorsque j'exécute le programme sans le mode débogage, les exceptions ne sont plus gérées. J'obtiens la boîte d'exception non gérée.

Je ne veux pas que cela se produise. Je veux que toutes les exceptions soient capturées lorsque le programme est exécuté en mode non-débogage. Le programme a plusieurs threads et il est préférable que toutes les exceptions soient capturées par le même gestionnaire ; je veux enregistrer les exceptions dans la base de données. Je veux enregistrer les exceptions dans la base de données. Quelqu'un a-t-il des conseils à me donner sur la façon de procéder ?

Answer 1

Regardez l'exemple de la page Documentation sur les exceptions de threads :

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);
}

Vous pouvez également souhaiter ne pas attraper d'exceptions lors du débogage, car cela facilite le débogage. C'est un peu un hack, mais pour cela vous pouvez envelopper le code ci-dessus avec

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

Pour éviter d'attraper les exceptions lors du débogage.

EDIT : Une autre façon de vérifier l'exécution de votre application dans un débogueur, plus propre que la vérification d'un nom de fichier.

(voir les commentaires de moltenform, Kiquenet et Doug)

if(!System.Diagnostics.Debugger.IsAttached) { ... }

Cela permet d'éviter le problème de l'utilisation d'un débogueur différent de celui du vshost.exe .

Answer 2

Dans NET 4, certaines exceptions sont ne sont plus prises en compte par défaut ; il s'agit généralement d'exceptions qui indiquent un état corrompu (éventuellement fatal) de l'exécutable, comme une exception de violation d'accès.

Essayez d'utiliser la balise [HandleProcessCorruptedStateExceptions] devant votre méthode principale, par exemple

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;
  }

Answer 3

Un bon exemple se trouve à l'adresse suivante http://www.csharp-examples.net/catching-unhandled-exceptions/ En gros, changez votre principal en :

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");
    }

Answer 4

Vous pouvez utiliser NBug pour cela. Avec une configuration minimale comme celle-ci :

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;

Vous pouvez commencer à collecter des informations sur tous les bogues non gérés dans votre application, même lorsqu'elle est déployée auprès des clients. Si vous ne souhaitez pas utiliser une bibliothèque tierce, vous devriez vous attacher aux événements ci-dessous :

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