Captura de exceção da interface - antes de criar o identificador da janela, você não pode chamar Invoke ou BeginInvoke no controle

@ 坏坏 Dong
encontrou um problema no projeto.Antes de criar o identificador da janela, você não pode chamar Invoke ou BeginInvoke no controle. No processo do projeto, ao depurar no Visual Studio, o programa geralmente apresenta esse erro durante a operação e a interface inteira é anormal. E o tempo do erro é irregular, às vezes não há erros por alguns dias e às vezes o erro é relatado com frequência; e quando essa interface estiver em execução, ela ocupará mais de 90% dos recursos da CPU, o que às vezes faz com que a interface fique presa.
Os programadores costumam dizer "eu te amo". Leva apenas três segundos para falar, três horas para explicar e uma vida inteira para provar. As três letras "Bug", leva três segundos para encontrar e três horas para encontrar, mas leva uma vida inteira para depurar. "Mesmo um programador sênior escreverá um bug, mas o bug não é terrível. O importante é localizar rapidamente o bug quando o bug ocorrer.

Peça ao
meu irmão que peça uma solução para o problema: Primeiro, eu estou no thread da interface principal e estou relacionado No método, try {} catch {} a exceção foi adicionada ao código, mas não funcionou.Verificou-se que a interface não fazia nada e não executava nenhuma operação, interrompia e lançava a exceção, então tentei as seguintes medidas:

1. Adicione aproximadamente uma captura de exceção na entrada do programa

Adicione este método de captura de exceção ao método de código para capturar o local do erro

try
{

}
catch (Exception ex)
{
   MessageBox.Show("位置：" + "[" + ex.Source + "]" +  "\r\n" + ex.StackTrace +  "\r\n" 
                   + "信息：" + "[" + ex.GetType() + "]" + ex.Message, "ExceptionInfo");
}
//说明
//ex.Source      获取导致错误的应用对象的名称
//ex.StackTrace  异常堆栈，获取调用堆栈上的字符串表示形式
//ex.GetType()     获取错误的类型

Capture o erro:
Local: [Separator]
Exiba informações detalhadas (projeto, diretório, código .cs e número da linha) do local do erro em xxxx (localizado no local da função que relatou o erro)
Informações: Obtenha o tipo de erro e avise o erro chinês

2. Captura de exceção global, capture a exceção de todo o programa

Defina try ... Catch na entrada do programa. A exceção catch
é lançada através do comando Throw e lançada totalmente a partir do módulo thrown. Se não for capturada pelo try ... catch ... no meio, será lançada para o CLR ( Common language runtime). Se você usar a pilha para descrever esse processo, é que a exceção afundará todo o caminho da parte superior da pilha até que seja capturada por try ... catch ... ou até que afunde na parte inferior da pilha e seja capturada pelo CLR. O tratamento do CLR após o recebimento da exceção é muito simples e relata de maneira rude e direta um erro e, em seguida, fecha o programa

try
{
   Application.EnableVisualStyles();
   Application.SetCompatibleTextRenderingDefault(false);
   Application.Run(new Form1());
}
catch (Exception ex)
{
   MessageBox.Show("位置：" + "[" + ex.Source + "]" +  "\r\n" + ex.StackTrace +  "\r\n"
                   + "信息：" + "[" + ex.GetType() + "]" + ex.Message, "ExceptionInfo");
}

Capture exceções globais. A exceção de todo o programa é capturada de uma só vez, sem adicionar uma por uma, esse método também não sabe se a exceção no encadeamento filho pode ser capturada.

3. Monitoramento de Eventos Application.ThreadException

A classe Application é responsável por controlar a operação de todo o programa Windows, usando um evento de uma classe Application: ThreadException

static void Main()
{
    AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandleException);
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new Form1());
}
private static void CurrentDomain_UnhandleException(object sender,UnhandledExceptionEventArgs e)
{
    Exception ex = e.Exception;
    MessageBox.Show(string.Format("捕获到未处理异常：{0}\r\n异常信息：{1}\r\n异常堆栈：{2}", ex.GetType(), ex.Message, ex.StackTrace));
}

Resultado: falhou

4. Exceção de subencadeamento capturada AppDomain.CurrentDomain.UnhandledException

Você pode capturar exceções do programa ouvindo o evento Application.ThreadException, mas esse evento Application.ThreadException pode capturar apenas exceções que ocorrem no thread principal do programa. Se você usar multithreading e ocorrer uma exceção no thread filho, o evento Application.ThreadException não será acionado. Se quisermos ouvir a exceção do encadeamento filho, precisamos registrar outro evento: AppDomain.CurrentDomain.UnhandledException Esse evento ocorre apenas quando uma exceção sem tratamento ocorre no domínio do programa atual (se o evento Application.ThreadException não for monitorado, a exceção do encadeamento principal eventualmente Também acionará este evento)

static class Program
{
    /// <summary>
    /// 应用程序的主入口点。
    /// </summary>
    [STAThread]
    static void Main()
    {
        //处理UI线程异常
        Application.ThreadException += Application_ThreadException;
        //处理非UI线程异常
        AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
        //应用程序的主入口点
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new FrmMain());
    }
     
    static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
    {
        Exception ex = e.ExceptionObject as Exception;
        MessageBox.Show(string.Format("捕获到未处理异常：{0}\r\n异常信息：{1}\r\n异常堆栈：{2}\r\nCLR即将退出：{3}", ex.GetType(), ex.Message, ex.StackTrace, e.IsTerminating));
    }
     
    static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e)
    {
        Exception ex = e.Exception;
        MessageBox.Show(string.Format("捕获到未处理异常：{0}\r\n异常信息：{1}\r\n异常堆栈：{2}", ex.GetType(), ex.Message, ex.StackTrace));
    }
}

** Precisamos prestar atenção a isso: O evento AppDomain.CurrentDomain.UnhandledException possui um parâmetro de evento chamado UnhandledExceptionEventArgs e, que possui uma propriedade IsTerminating do tipo bool. Este atributo indica se o CLR (Common Language Runtime) será encerrado devido a essa exceção. Se esse atributo for verdadeiro, podemos chamar esse erro de irreparável, mesmo que escutemos esse evento. Após a execução do código desse evento, todo o programa ainda falhará e sairá (porque eu estou no VS, então estava VS pegou.)

As anomalias foram detectadas dessa maneira;

consulte o site de aprendizado:
https://www.cnblogs.com/tomahawk/articles/5993874.html
https://www.cnblogs.com/wangshenhe/archive/2012/11/14/ 2769605.html

Finalmente:
no programa Windows, se o evento Application.ThreadException e o evento AppDomain.CurrentDomain.UnhandledException forem monitorados ao mesmo tempo, a exceção será capturada pelo evento Application.ThreadException primeiro. No entanto, o evento Application.ThreadException pode apenas ouvir exceções lançadas pelo thread principal do programa.