Application.ThreadException Evento

Definición

Espacio de nombres:

System.Windows.Forms

Ensamblado:

System.Windows.Forms.dll

Source:

Application.cs

Ocurre cuando se produce una excepción de subproceso no interceptada.

C#

public static event System.Threading.ThreadExceptionEventHandler? ThreadException;

Tipo de evento

ThreadExceptionEventHandler

Ejemplos

En el ejemplo de código siguiente se establecen controladores de eventos para las excepciones que se producen en Windows Forms subprocesos y excepciones que se producen en otros subprocesos. Establece SetUnhandledExceptionMode para que la aplicación controle todas las excepciones, independientemente de la configuración del archivo de configuración de usuario de la aplicación. Usa el ThreadException evento para controlar las excepciones de subprocesos de la interfaz de usuario y el UnhandledException evento para controlar excepciones de subprocesos que no son de interfaz de usuario. Dado que UnhandledException no se puede impedir que una aplicación finalice, el ejemplo simplemente registra el error en el registro de eventos de la aplicación antes de la finalización.

En este ejemplo se supone que ha definido dos Button controles y button1button2, en la Form clase .

C#

Thread newThread = null;

// Starts the application.
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);

    // Runs the application.
    Application.Run(new ErrorHandlerForm());
}

// Programs the button to throw an exception when clicked.
private void button1_Click(object sender, System.EventArgs e)
{
    throw new ArgumentException("The parameter was invalid");
}

// Start a new thread, separate from Windows Forms, that will throw an exception.
private void button2_Click(object sender, System.EventArgs e)
{
    ThreadStart newThreadStart = new ThreadStart(newThread_Execute);
    newThread = new Thread(newThreadStart);
    newThread.Start();
}

// The thread we start up to demonstrate non-UI exception handling.
void newThread_Execute()
{
    throw new Exception("The method or operation is not implemented.");
}

// Handle the UI exceptions by showing a dialog box, and asking the user whether
// or not they wish to abort execution.
private static void Form1_UIThreadException(object sender, ThreadExceptionEventArgs t)
{
    DialogResult result = DialogResult.Cancel;
    try
    {
        result = ShowThreadExceptionDialog("Windows Forms Error", t.Exception);
    }
    catch
    {
        try
        {
            MessageBox.Show("Fatal Windows Forms Error",
                "Fatal Windows Forms Error", MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Stop);
        }
        finally
        {
            Application.Exit();
        }
    }

    // Exits the program when the user clicks Abort.
    if (result == DialogResult.Abort)
        Application.Exit();
}

// Handle the UI exceptions by showing a dialog box, and asking the user whether
// or not they wish to abort execution.
// NOTE: This exception cannot be kept from terminating the application - it can only
// log the event, and inform the user about it.
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
    try
    {
        Exception ex = (Exception)e.ExceptionObject;
        string errorMsg = "An application error occurred. Please contact the adminstrator " +
            "with the following information:\n\n";

        // Since we can't prevent the app from terminating, log this to the event log.
        if (!EventLog.SourceExists("ThreadException"))
        {
            EventLog.CreateEventSource("ThreadException", "Application");
        }

        // Create an EventLog instance and assign its source.
        EventLog myLog = new EventLog();
        myLog.Source = "ThreadException";
        myLog.WriteEntry(errorMsg + ex.Message + "\n\nStack Trace:\n" + ex.StackTrace);
    }
    catch (Exception exc)
    {
        try
        {
            MessageBox.Show("Fatal Non-UI Error",
                "Fatal Non-UI Error. Could not write the error to the event log. Reason: "
                + exc.Message, MessageBoxButtons.OK, MessageBoxIcon.Stop);
        }
        finally
        {
            Application.Exit();
        }
    }
}

// Creates the error message and displays it.
private static DialogResult ShowThreadExceptionDialog(string title, Exception e)
{
    string errorMsg = "An application error occurred. Please contact the adminstrator " +
        "with the following information:\n\n";
    errorMsg = errorMsg + e.Message + "\n\nStack Trace:\n" + e.StackTrace;
    return MessageBox.Show(errorMsg, title, MessageBoxButtons.AbortRetryIgnore,
        MessageBoxIcon.Stop);
}

Comentarios

Este evento permite que la aplicación de Windows Forms controle las excepciones no controladas que se producen en Windows Forms subprocesos. Adjunte el controlador de eventos al ThreadException evento para tratar estas excepciones, lo que dejará la aplicación en un estado desconocido. Siempre que sea posible, las excepciones se deben controlar mediante un bloque de control de excepciones estructurado.

Puede cambiar si esta devolución de llamada se usa para excepciones de subprocesos no controladas Windows Forms estableciendo SetUnhandledExceptionMode. Para detectar excepciones que se producen en subprocesos no creados y propiedad de Windows Forms, use el UnhandledException controlador de eventos.

Nota

Para garantizar que no se pierda ninguna activación de este evento, debe adjuntar un controlador antes de llamar a Application.Run.

Nota

Solo se puede adjuntar un controlador a este evento. Si se agregan varios controladores, solo se llamará al controlador agregado más recientemente en una excepción no controlada.

Precaución

Dado que se trata de un evento estático, debe desasociar los controladores de eventos cuando se elimina la aplicación o se producirán pérdidas de memoria.

Se aplica a