propiedades - que son excepciones en c#

¿Por qué la excepción interna llega al controlador ThreadException y no a la excepción lanzada real?

Question

Estoy viendo un comportamiento extraño al lanzar excepciones y atraparlas en el controlador de eventos Application.ThreadException .

Básicamente, lo que sucede en el ejemplo a continuación es que se lanza una excepción en el controlador de eventos DoWork de un BackgroundWorker . El RunWorkerCompleted eventos RunWorkerCompleted vuelve a lanzar una nueva excepción con el original como la excepción interna.

¿Por qué aparece la excepción interna en el controlador de eventos ThreadException y no la excepción acutal que se lanza? Si no proporciono una excepción interna en el controlador de eventos RunWorkerCompleted , se mostrará la excepción correcta.

using System;
using System.Windows.Forms;
using System.ComponentModel;

namespace WierdExceptionApp
{
    class WierdExceptionForm : Form
    {
        BackgroundWorker worker = new BackgroundWorker();

        public WierdExceptionForm()
        {
            worker.DoWork += new DoWorkEventHandler(worker_DoWork);
            worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
            worker.RunWorkerAsync();
        }

        void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Error != null)
            {
                throw new Exception("worker_RunWorkerCompleted", e.Error);
            }
        }

        void worker_DoWork(object sender, DoWorkEventArgs e)
        {
            throw new Exception("worker_DoWork");
        }

        [STAThread]
        static void Main()
        {
            Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
            Application.Run(new WierdExceptionForm());
        }

        static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e)
        {
            MessageBox.Show(e.Exception.Message);
        }
   }
}

Answer 1

El evento RunWorkerCompleted se clasifica desde el hilo BGW al hilo de la interfaz de usuario por la fontanería WF que hace que funcione Control.Invoke (). Básicamente, hay una cola con delegados que se vacía por el ciclo de mensajes. El código que hace esto, Control.InvokeMarshaledCallbacks (), lo verá en la pila de llamadas, tiene una cláusula catch (Exception) para capturar las excepciones no controladas. Esa cláusula llama a Application.OnThreadException, pasando el valor de Exception.GetBaseException ().

Bueno, eso explica por qué solo ves la excepción interna. Por qué se hace de esta manera es un poco confuso. Posiblemente para cortar los fotogramas de pila del código en el subproceso de interfaz de usuario que, de lo contrario, son bastante confusos ya que la excepción real provino del hilo de fondo.

Answer 2

        if (e.Error != null)
        {
            throw new Exception("worker_RunWorkerCompleted", new Exception("Inner", new Exception("Inner inner")));
        }

Obtienes "interior interno" al final. Parece que este es el comportamiento del método Application_ThreadException para ver la excepción más interna.