Exportar (0) Imprimir
Expandir todo
Expandir Minimizar

UnhandledExceptionMode (Enumeración)

Define a dónde debe enviar una aplicación de Windows Forms las excepciones no controladas.

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

public enum UnhandledExceptionMode
public enum UnhandledExceptionMode
public enum UnhandledExceptionMode

 Nombre de miembroDescripción
AutomaticEnrutar todas las excepciones al controlador de ThreadException, a menos que el archivo de configuración de la aplicación especifique lo contrario. 
CatchExceptionEnrutar siempre las excepciones al controlador de ThreadException. Omitir el archivo de configuración de la aplicación. 
ThrowExceptionNo enrutar nunca las excepciones al controlador de ThreadException. Omitir el archivo de configuración de la aplicación. 

SetUnhandledExceptionMode utiliza esta enumeración.

En el ejemplo de código siguiente se establecen controladores de eventos para los errores que se producen en los subprocesos de formularios Windows Forms y los que se producen en otros subprocesos. Establece SetUnhandledExceptionMode de modo que todos los errores son controlados por la aplicación, con independencia de los valores del archivo de configuración del usuario de la aplicación. Utiliza el evento ThreadException para el primero y el evento UnhandledException para el último. Dado que una excepción UnhandledException no puede impedir que finalice una aplicación, el ejemplo se limita a registrar el error en el registro de eventos del sistema antes de la finalización.

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

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

// Creates a class to throw the error.
public static class ErrorHandler extends System.Windows.Forms.Form
{
    // Inserts the code to create a form with a button.
    // 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");
    } //button1_Click

    public static void main(String[] args)
    {
        // Creates an instance of the methods that will handle 
        // the exception.
        CustomExceptionHandler eh = new CustomExceptionHandler();

        // Adds the event handler to to the event.
        Application.add_ThreadException(
            new ThreadExceptionEventHandler(eh.OnThreadException));

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

// Creates a class to handle the exception event.
static class CustomExceptionHandler
{
    // Handles the exception event.
    public void OnThreadException(Object sender, ThreadExceptionEventArgs t)
    {
        DialogResult result = DialogResult.Cancel;
        try {
            result = this.ShowThreadExceptionDialog(t.get_Exception());
        }
        catch (System.Exception exp) {
            try {
                MessageBox.Show("Fatal Error", "Fatal Error", 
                    MessageBoxButtons.AbortRetryIgnore, 
                    MessageBoxIcon.Stop);
            }
            finally {
                Application.Exit();
            }
        }

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

    // Creates the error message and displays it.
    private DialogResult ShowThreadExceptionDialog(System.Exception e)
    {
        String errorMsg = "An error occurred please contact the"
            + " administrator with the following information:\n\n";
        errorMsg = errorMsg + e.get_Message() + "\n\nStack Trace:\n"
            + e.get_StackTrace();
        return MessageBox.Show(errorMsg, "Application Error",
            MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Stop);
    } //ShowThreadExceptionDialog
} //CustomExceptionHandler

public static void main(String[] args)
{
    ErrorHandler.main(args);
}//main

Windows 98, Windows 2000 Service Pack 4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter

Microsoft .NET Framework 3.0 es compatible con Windows Vista, Microsoft Windows XP SP2 y Windows Server 2003 SP1.

.NET Framework

Compatible con: 3.0, 2.0
Mostrar:
© 2014 Microsoft