Salir de la aplicación de consola en C#

Para finalizar una aplicación de consola en C# cuando haya terminado su trabajo, devuelve el control desde Main. Usa Environment.Exit() solo si el proceso debe detenerse inmediatamente desde otro método. Devolver un entero desde Main o pasarlo a Environment.Exit(int) proporciona el código de salida del proceso; el texto de la consola es independiente de ese código.

Volver desde Main para finalizar la aplicación

Una instrucción return termina el método actual. Cuando termina Main, finaliza la ejecución normal de la aplicación; las instrucciones posteriores a return no se ejecutan. Un return desde un método anidado solo devuelve el control a quien lo llamó, por lo que no finaliza la aplicación por sí solo. Para una finalización normal, es preferible devolver el control desde Main: así se sigue el flujo habitual del programa y pueden ejecutarse los bloques finally y la limpieza de recursos correspondientes.

Un void Main() puede usar return; para terminar sin devolver un valor. Un int Main() puede devolver un código de salida. Este ejemplo completo imprime una línea de estado y devuelve el código convencional de éxito. La observación de ejecución suministrada produjo Work completed. y el código de salida 0.

Ejecuta este ejemplo:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

using System;

class Program
{
    static int Main()
    {
        Console.WriteLine("Work completed.");
        return 0;
    }
}

Work completed.

La instrucción return 0; termina Main, y el sistema operativo o el proceso que llamó al programa recibe 0. Si necesitas indicar un error, devuelve un código distinto de cero. El significado exacto de cada valor distinto de cero lo define tu programa o quien lo invoca.

Usar Environment.Exit() para terminar desde cualquier método

Environment.Exit(int) puede terminar el proceso desde un método distinto de Main. Finaliza el proceso de inmediato con el código de salida entero proporcionado y no devuelve el control a quien lo llamó. Resérvalo para situaciones en las que no se pueda seguir el flujo normal de finalización, como un apagado deliberadamente inmediato; por lo general, el manejo habitual de errores debería informar del problema y devolver desde Main un código apropiado.

Este ejemplo completo llama a Environment.Exit(0) desde StopApplication, un método distinto de Main:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

using System;

class Program
{
    static void Main()
    {
        StopApplication();
        Console.WriteLine("This line is not reached.");
    }

    static void StopApplication()
    {
        Console.WriteLine("Stopping now.");
        Environment.Exit(0);
    }
}

La llamada proporciona el código de salida 0 y termina el proceso antes de que StopApplication devuelva el control, por lo que la ejecución nunca llega a la siguiente línea de Main. La observación de ejecución suministrada corresponde al ejemplo de Main anterior, no a este ejemplo. Una llamada como Environment.Exit(1); proporciona el código de salida 1; el entero se pasa al sistema operativo o al proceso que llamó al programa, mientras que cualquier mensaje escrito con Console.WriteLine es texto independiente de la consola. El método es estático en System.Environment, así que un archivo que incluya using System; puede llamarlo directamente.

Elegir un código de salida y comprender la limpieza

Por convención, se usa 0 para indicar éxito y un valor distinto de cero para indicar un error. Son convenciones, no una correspondencia universal para todas las aplicaciones: documenta los códigos que deba interpretar un script, un administrador de servicios u otro proceso que invoque el programa. Tanto devolver un entero desde Main como llamar a Environment.Exit(int) comunica el código de salida del proceso. Ninguno de esos valores se imprime automáticamente, así que muestra un mensaje de diagnóstico aparte cuando alguien necesite una explicación.

Si el programa puede finalizar normalmente, es preferible devolver el control desde Main. El retorno normal de los métodos permite ejecutar los bloques finally al salir del correspondiente bloque try, y los recursos con ámbito, como los declarados con using, pueden liberarse cuando termina su ámbito. Environment.Exit() detiene el proceso inmediatamente, sin desenrollar normalmente la pila; se omiten los bloques finally pendientes y la limpieza administrada. Antes de una terminación inmediata, vacía o cierra los recursos importantes mediante el flujo normal del programa, y evita ese método cuando la limpieza sea necesaria para conservar datos o liberar recursos.

Distinguir la salida del proceso de break, las excepciones y Ctrl+C

La instrucción break sale del bucle o switch más cercano; la ejecución continúa después de esa estructura. Si salir de un bucle debe finalizar el programa, deja que la ejecución llegue al final de Main o devuelve el control desde Main después del bucle.

Lanzar una excepción transfiere el control a un controlador compatible. Si este la captura y la ejecución continúa, el proceso no ha terminado. Gestiona la situación y, si la aplicación debe finalizar, elige después una ruta de retorno normal y un código de salida adecuado. Una excepción no controlada puede terminar un proceso, pero usarla solo como atajo para finalizar oculta el flujo de control y el manejo de errores previstos.

Ctrl+C es una solicitud de cancelación de la consola, no una orden que garantice una salida controlada. Un programa puede detectarla mediante Console.CancelKeyPress; que el proceso se detenga inmediatamente o que el controlador cancele la respuesta predeterminada depende del manejo del evento y del entorno anfitrión. Si la cancelación requiere limpieza, registra la solicitud y deja que el flujo principal detenga el trabajo y finalice normalmente.