Manipulador de exceção global do .NET no aplicativo de console

Pergunta: Desejo definir um manipulador de exceção global para exceções não tratadas no meu aplicativo de console. No asp.net, pode-se definir um em global.asax e, em aplicativos / serviços do Windows, pode-se definir como abaixo

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

Mas como posso definir um manipulador de exceção global para um aplicativo de console?
currentDomain parece não funcionar (.NET 2.0)?

Editar:

Argh, erro estúpido.
No VB.NET, é necessário adicionar a palavra-chave "AddHandler" na frente do currentDomain, caso contrário, não será exibido o evento UnhandledException no IntelliSense ...
Isso ocorre porque os compiladores VB.NET e C # tratam o tratamento de eventos de maneira diferente.

Não, essa é a maneira correta de fazer isso. Isso funcionou exatamente como deveria, algo em que você pode trabalhar:

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

Lembre-se de que não é possível capturar exceções de tipo e carregamento de arquivo geradas pelo jitter dessa maneira. Eles acontecem antes que o método Main () comece a ser executado. Capturar esses requer atrasar a instabilidade, mova o código arriscado para outro método e aplique o atributo [MethodImpl (MethodImplOptions.NoInlining)] a ele.

Se você tiver um aplicativo de thread único, poderá usar uma simples tentativa / captura na função Principal, no entanto, isso não cobre exceções que podem ser lançadas fora da função Principal, em outros threads, por exemplo (como observado em outros comentários). Este código demonstra como uma exceção pode causar o encerramento do aplicativo, mesmo que você tenha tentado manipulá-lo no Main (observe como o programa sai normalmente se você pressionar enter e permitir que o aplicativo saia normalmente antes que a exceção ocorra, mas se você permitir a execução , termina bastante infeliz):

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

Você pode receber uma notificação de quando outro encadeamento lança uma exceção para executar alguma limpeza antes da saída do aplicativo, mas, pelo que sei, não é possível, a partir de um aplicativo de console, forçar o aplicativo a continuar em execução se você não manipular a exceção no encadeamento do qual ele é lançado sem usar algumas opções de compatibilidade obscuras para fazer com que o aplicativo se comporte como no .NET 1.x. Este código demonstra como o thread principal pode ser notificado sobre exceções provenientes de outros threads, mas ainda será finalizado infelizmente:

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

Portanto, na minha opinião, a maneira mais limpa de lidar com isso em um aplicativo de console é garantir que cada encadeamento tenha um manipulador de exceções no nível raiz:

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

Você também precisa lidar com exceções de threads:

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

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

Opa, desculpe pelo uso do winforms, para todos os threads que você estiver usando em um aplicativo de console, será necessário incluir um bloco try / catch. Os encadeamentos em segundo plano que encontram exceções sem tratamento não fazem com que o aplicativo seja finalizado.

Acabei de herdar um aplicativo de console antigo do VB.NET e precisava configurar um manipulador de exceção global. Como essa pergunta menciona o VB.NET algumas vezes e está marcada com o VB.NET, mas todas as outras respostas aqui estão em C #, pensei em adicionar a sintaxe exata para um aplicativo VB.NET também.

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

Usei o REMmarcador de comentário em vez da aspas simples aqui, porque o Stack Overflow parecia lidar com a sintaxe destacando um pouco melhor REM.

O que você está tentando deve funcionar de acordo com os documentos do MSDN para .Net 2.0. Você também pode tentar uma tentativa / captura diretamente no ponto de entrada do aplicativo de console.

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

E agora a sua captura vai lidar com qualquer coisa não capturada ( na thread principal ). Pode ser simples e até reiniciar onde estava, se você quiser, ou você pode simplesmente deixar o aplicativo morrer e registrar a exceção. Você adicionará um finalmente se quiser fazer alguma limpeza. Cada encadeamento exigirá seu próprio tratamento de exceção de alto nível semelhante ao principal.

Editado para esclarecer o ponto sobre os tópicos, como apontado por BlueMonkMN e mostrado em detalhes em sua resposta.