Sair do aplicativo de console em C#

Para encerrar um aplicativo de console em C# após concluir seu trabalho, retorne de Main. Use Environment.Exit() somente quando o processo precisar ser encerrado imediatamente a partir de outro método. Retornar um inteiro de Main ou passá-lo a Environment.Exit(int) fornece o código de saída do processo; o texto exibido no console é separado desse código.

Retornar de Main para encerrar o aplicativo

Uma instrução return encerra o método atual. Quando encerra Main, a execução normal do aplicativo termina; as instruções após o retorno não são executadas. Um retorno de um método aninhado apenas devolve o controle ao método que o chamou, portanto não encerra o aplicativo por si só. Para uma conclusão normal, prefira retornar de Main: isso segue o fluxo de controle habitual e permite que os blocos finally ao redor sejam executados e que os recursos sejam liberados.

Um void Main() pode usar return; para terminar sem retornar um valor. Um int Main() pode retornar um código de saída. Este exemplo completo exibe uma linha de status e retorna o código convencional de sucesso. Na observação de execução fornecida, o resultado foi Work completed. e o código de saída foi 0.

Execute este exemplo:

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

using System;

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

Work completed.

A instrução return 0; encerra Main, e o sistema operacional ou processo chamador recebe 0. Para indicar uma falha, retorne um código diferente de zero. O significado exato de cada valor diferente de zero é definido pelo seu programa ou por quem o chama.

Usar Environment.Exit() para encerrar a partir de qualquer método

Environment.Exit(int) pode encerrar o processo a partir de um método que não seja Main. Ele termina o processo imediatamente com o código de saída inteiro fornecido e não retorna ao método que o chamou. Reserve esse método para situações em que não seja possível seguir o encerramento normal, como um desligamento imediato deliberado; em geral, o tratamento normal de erros deve relatar o problema e retornar de Main com um código apropriado.

Este exemplo completo chama Environment.Exit(0) em StopApplication, um método diferente de Main:

O código e os rótulos ou saídas exibidos nesta seção permanecem em 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);
    }
}

A chamada fornece o código de saída 0 e encerra o processo antes que StopApplication retorne; por isso, o controle nunca chega à linha seguinte em Main. A observação de execução fornecida corresponde ao exemplo de Main acima, não a este exemplo. Uma chamada como Environment.Exit(1); fornece o código de saída 1; o inteiro é passado ao sistema operacional ou processo chamador, enquanto qualquer mensagem exibida com Console.WriteLine é uma saída separada do console. O método é estático em System.Environment, portanto um arquivo que use using System; pode chamá-lo diretamente.

Escolher um código de saída e entender a limpeza

Por convenção, use 0 para indicar sucesso e um valor diferente de zero para indicar falha. Essas são convenções, não um mapeamento universal válido para todos os aplicativos: documente os códigos que um script, gerenciador de serviços ou outro chamador precisa interpretar. Tanto retornar um inteiro de Main quanto chamar Environment.Exit(int) comunica um código de saída do processo. Nenhum desses valores é exibido automaticamente; se uma pessoa precisar de uma explicação, exiba uma mensagem diagnóstica separada.

Prefira retornar de Main quando o programa puder terminar normalmente. O retorno normal de um método permite que os blocos finally sejam executados quando o controle sai de suas instruções try e que recursos com escopo, como declarações using, sejam liberados ao fim de seus escopos. Environment.Exit() encerra o processo imediatamente, sem desenrolar a pilha normalmente; blocos finally pendentes e a limpeza gerenciada são ignorados. Antes de encerrar o processo imediatamente, descarregue ou feche recursos importantes pelo fluxo normal de controle. Evite esse método quando a limpeza for necessária para preservar dados ou liberar recursos.

Diferenciar o encerramento do processo de break, exceções e Ctrl+C

Uma instrução break sai do loop ou switch mais próximo; a execução continua após essa estrutura. Se sair de um loop deve encerrar o programa, deixe a execução chegar ao fim de Main ou retorne de Main após o loop.

Lançar uma exceção transfere o controle para um manipulador correspondente. Se o manipulador capturá-la e a execução continuar, o processo não foi encerrado. Trate a condição e, se o aplicativo precisar terminar, escolha um caminho normal de retorno e um código de saída apropriado. Uma exceção não tratada pode encerrar um processo, mas usá-la apenas como atalho para terminar obscurece o fluxo de controle e o tratamento de erros pretendidos.

Ctrl+C é uma solicitação de cancelamento enviada pelo console, não um comando que garante um encerramento gradual. Um programa pode detectá-la por meio de Console.CancelKeyPress; o processo parar imediatamente ou o manipulador cancelar a resposta padrão depende do tratamento do evento e do ambiente de hospedagem. Se o cancelamento exigir limpeza, registre a solicitação e deixe o fluxo principal interromper o trabalho e retornar normalmente.