Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Application.SetUnhandledExceptionMode (UnhandledExceptionMode, Boolean)

 

Publicado: octubre de 2016

Indica a la aplicación cómo responder a las excepciones no controladas, aplicando opcionalmente el comportamiento específico del subproceso.

Espacio de nombres:   System.Windows.Forms
Ensamblado:  System.Windows.Forms (en System.Windows.Forms.dll)

public static void SetUnhandledExceptionMode(
	UnhandledExceptionMode mode,
	bool threadScope
)

Parámetros

mode
Type: System.Windows.Forms.UnhandledExceptionMode

Valor UnhandledExceptionMode que describe cómo debe comportarse la aplicación si se produce una excepción no detectada.

threadScope
Type: System.Boolean

true Para establecer el modo de excepción del subproceso; de lo contrario, false.

Exception Condition
InvalidOperationException

No se puede establecer el modo de excepción después de que la aplicación ha creado su primera ventana.

A menudo no es factible detectar todas las excepciones producidas por los formularios Windows Forms. Con este método, puede indicar a su aplicación si debe detectar excepciones no controladas todo producidas por componentes de Windows Forms y seguir funcionando, o si debe exponerlas al usuario y detener la ejecución.

Llame a SetUnhandledExceptionMode antes de crear el formulario principal de la aplicación mediante el Run método.

Cuando threadScope es true, se establece el modo de excepción del subproceso. El modo de excepción del subproceso reemplaza el modo de excepción de aplicación si mode no está establecido en Automatic.

Cuando threadScope es false, se establece el modo de excepción de aplicación. Se utiliza el modo de excepción de aplicación para todos los subprocesos que tienen el Automatic modo. Establecer el modo de excepción de aplicación no afecta a la configuración del subproceso actual.

Para detectar excepciones que se producen en subprocesos que no se crean y propiedad de formularios Windows Forms, use la UnhandledException controlador de eventos.

En el ejemplo de código siguiente se establece controladores de eventos para las excepciones que se producen en los subprocesos de formularios Windows Forms y excepciones que se producen en otros subprocesos. Establece SetUnhandledExceptionMode para que todas las excepciones se controlan mediante la aplicación, independientemente de la configuración en el archivo de configuración de usuario de la aplicación. Usa el ThreadException eventos para controlar las excepciones del subproceso de interfaz de usuario y UnhandledException eventos para controlar las excepciones del subproceso de interfaz de usuario no. Puesto que UnhandledException no puede impedir que una aplicación de finalización, el ejemplo simplemente registra el error en el registro de eventos de aplicación antes de la finalización.

En este ejemplo se supone que ha definido dos Button controles, button1 y button2, en su Form clase.

Thread newThread = null;

// Starts the application. 
[SecurityPermission(SecurityAction.Demand, Flags = SecurityPermissionFlag.ControlAppDomain)]
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);
}

.NET Framework
Disponible desde 2.0
Volver al principio
Mostrar: