Gestionnaire d'exceptions globales .NET dans l'application console

Question: Je souhaite définir un gestionnaire d'exceptions global pour les exceptions non gérées dans mon application console. Dans asp.net, on peut en définir un dans global.asax, et dans les applications / services Windows, on peut définir comme ci-dessous

AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.UnhandledException += new UnhandledExceptionEventHandler(MyExceptionHandler);

Mais comment puis-je définir un gestionnaire d'exceptions global pour une application console?
currentDomain ne semble pas fonctionner (.NET 2.0)?

Éditer:

Argh, stupide erreur.
Dans VB.NET, il faut ajouter le mot clé "AddHandler" devant currentDomain, sinon on ne voit pas l'événement UnhandledException dans IntelliSense ...
C'est parce que les compilateurs VB.NET et C # traitent la gestion des événements différemment.

Non, c'est la bonne façon de procéder. Cela a fonctionné exactement comme il se doit, quelque chose à partir duquel vous pouvez travailler:

using System;

class Program {
    static void Main(string[] args) {
        System.AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionTrapper;
        throw new Exception("Kaboom");
    }

    static void UnhandledExceptionTrapper(object sender, UnhandledExceptionEventArgs e) {
        Console.WriteLine(e.ExceptionObject.ToString());
        Console.WriteLine("Press Enter to continue");
        Console.ReadLine();
        Environment.Exit(1);
    }
}

Gardez à l'esprit que vous ne pouvez pas intercepter les exceptions de type et de chargement de fichier générées par la gigue de cette façon. Ils se produisent avant que votre méthode Main () ne démarre. Pour les attraper, il faut retarder la gigue, déplacer le code risqué dans une autre méthode et lui appliquer l'attribut [MethodImpl (MethodImplOptions.NoInlining)].

Si vous avez une application à un seul thread, vous pouvez utiliser un simple try / catch dans la fonction Main, cependant, cela ne couvre pas les exceptions qui peuvent être levées en dehors de la fonction Main, sur d'autres threads, par exemple (comme indiqué dans d'autres commentaires). Ce code montre comment une exception peut entraîner la fermeture de l'application même si vous avez essayé de la gérer dans Main (notez comment le programme se termine correctement si vous appuyez sur Entrée et autorisez l'application à se fermer correctement avant que l'exception ne se produise, mais si vous la laissez s'exécuter) , il se termine malheureusement):

static bool exiting = false;

static void Main(string[] args)
{
   try
   {
      System.Threading.Thread demo = new System.Threading.Thread(DemoThread);
      demo.Start();
      Console.ReadLine();
      exiting = true;
   }
   catch (Exception ex)
   {
      Console.WriteLine("Caught an exception");
   }
}

static void DemoThread()
{
   for(int i = 5; i >= 0; i--)
   {
      Console.Write("24/{0} =", i);
      Console.Out.Flush();
      Console.WriteLine("{0}", 24 / i);
      System.Threading.Thread.Sleep(1000);
      if (exiting) return;
   }
}

Vous pouvez recevoir une notification lorsqu'un autre thread lève une exception pour effectuer un nettoyage avant la fermeture de l'application, mais pour autant que je sache, vous ne pouvez pas, à partir d'une application console, forcer l'application à continuer de fonctionner si vous ne gérez pas l'exception sur le thread à partir duquel elle est lancée sans utiliser certaines options de compatibilité obscures pour que l'application se comporte comme elle l'aurait fait avec .NET 1.x. Ce code montre comment le thread principal peut être notifié des exceptions provenant d'autres threads, mais se terminera toujours malheureusement:

static bool exiting = false;

static void Main(string[] args)
{
   try
   {
      System.Threading.Thread demo = new System.Threading.Thread(DemoThread);
      AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
      demo.Start();
      Console.ReadLine();
      exiting = true;
   }
   catch (Exception ex)
   {
      Console.WriteLine("Caught an exception");
   }
}

static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
   Console.WriteLine("Notified of a thread exception... application is terminating.");
}

static void DemoThread()
{
   for(int i = 5; i >= 0; i--)
   {
      Console.Write("24/{0} =", i);
      Console.Out.Flush();
      Console.WriteLine("{0}", 24 / i);
      System.Threading.Thread.Sleep(1000);
      if (exiting) return;
   }
}

Donc, à mon avis, la façon la plus propre de le gérer dans une application console est de s'assurer que chaque thread a un gestionnaire d'exceptions au niveau racine:

static bool exiting = false;

static void Main(string[] args)
{
   try
   {
      System.Threading.Thread demo = new System.Threading.Thread(DemoThread);
      demo.Start();
      Console.ReadLine();
      exiting = true;
   }
   catch (Exception ex)
   {
      Console.WriteLine("Caught an exception");
   }
}

static void DemoThread()
{
   try
   {
      for (int i = 5; i >= 0; i--)
      {
         Console.Write("24/{0} =", i);
         Console.Out.Flush();
         Console.WriteLine("{0}", 24 / i);
         System.Threading.Thread.Sleep(1000);
         if (exiting) return;
      }
   }
   catch (Exception ex)
   {
      Console.WriteLine("Caught an exception on the other thread");
   }
}

Vous devez également gérer les exceptions des threads:

static void Main(string[] args) {
Application.ThreadException += MYThreadHandler;
}

private void MYThreadHandler(object sender, Threading.ThreadExceptionEventArgs e)
{
    Console.WriteLine(e.Exception.StackTrace);
}

Oups, désolé pour Winforms, pour tous les threads que vous utilisez dans une application console, vous devrez les placer dans un bloc try / catch. Les threads d'arrière-plan qui rencontrent des exceptions non gérées ne provoquent pas la fin de l'application.

Je viens d'hériter d'une ancienne application de console VB.NET et j'avais besoin de configurer un gestionnaire d'exceptions global. Étant donné que cette question mentionne VB.NET à quelques reprises et est étiquetée avec VB.NET, mais toutes les autres réponses ici sont en C #, j'ai pensé que j'ajouterais également la syntaxe exacte pour une application VB.NET.

Public Sub Main()
    REM Set up Global Unhandled Exception Handler.
    AddHandler System.AppDomain.CurrentDomain.UnhandledException, AddressOf MyUnhandledExceptionEvent

    REM Do other stuff
End Sub

Public Sub MyUnhandledExceptionEvent(ByVal sender As Object, ByVal e As UnhandledExceptionEventArgs)
    REM Log Exception here and do whatever else is needed
End Sub

J'ai utilisé le REMmarqueur de commentaire au lieu de la citation simple ici parce que Stack Overflow semblait gérer la syntaxe en soulignant un peu mieux avec REM.

Ce que vous essayez devrait fonctionner selon les documents MSDN pour .Net 2.0. Vous pouvez également essayer un try / catch en main autour de votre point d'entrée pour l'application console.

static void Main(string[] args)
{
    try
    {
        // Start Working
    }
    catch (Exception ex)
    {
        // Output/Log Exception
    }
    finally
    {
        // Clean Up If Needed
    }
}

Et maintenant, votre capture gérera tout ce qui n'est pas capturé ( dans le fil principal ). Il peut être gracieux et même redémarrer là où il était si vous le souhaitez, ou vous pouvez simplement laisser l'application mourir et enregistrer l'exception. Vous ajouterez enfin un si vous vouliez faire un nettoyage. Chaque thread nécessitera sa propre gestion des exceptions de haut niveau similaire à la principale.

Modifié pour clarifier le point sur les threads comme souligné par BlueMonkMN et montré en détail dans sa réponse.