Como manter um aplicativo de console .NET em execução?

Considere um aplicativo de console que inicializa alguns serviços em um thread separado. Tudo o que precisa fazer é esperar que o usuário pressione Ctrl + C para desligá-lo.

Qual das alternativas a seguir é a melhor maneira de fazer isso?

static ManualResetEvent _quitEvent = new ManualResetEvent(false);

static void Main() {
    Console.CancelKeyPress += (sender, eArgs) => {
        _quitEvent.Set();
        eArgs.Cancel = true;
    };

    // kick off asynchronous stuff 

    _quitEvent.WaitOne();

    // cleanup/shutdown and quit
}

Ou isso, usando Thread.Sleep (1):

static bool _quitFlag = false;

static void Main() {
    Console.CancelKeyPress += delegate {
        _quitFlag = true;
    };

    // kick off asynchronous stuff 

    while (!_quitFlag) {
        Thread.Sleep(1);
    }

    // cleanup/shutdown and quit
}

você sempre deseja evitar o uso de loops while, especialmente quando está forçando o código a verificar novamente as variáveis. Ele desperdiça recursos da CPU e retarda seu programa.

Eu definitivamente diria o primeiro.

Alternativamente, uma solução mais simples é apenas:

Console.ReadLine();

Você pode fazer isso (e remover o CancelKeyPressmanipulador de eventos):

while(!_quitFlag)
{
    var keyInfo = Console.ReadKey();
    _quitFlag = keyInfo.Key == ConsoleKey.C
             && keyInfo.Modifiers == ConsoleModifiers.Control;
}

Não tenho certeza se isso é melhor, mas não gosto da ideia de chamar Thread.Sleepem um loop .. Acho que é mais limpo bloquear a entrada do usuário.

Eu prefiro usar o Application.Run

static void Main(string[] args) {

   //Do your stuff here

   System.Windows.Forms.Application.Run();

   //Cleanup/Before Quit
}

dos documentos:

Começa a execução de um loop de mensagem de aplicativo padrão no segmento atual, sem um formulário.

Parece que você está tornando tudo mais difícil do que o necessário. Por que não apenas Joino tópico depois que você sinalizou para parar?

class Program
{
    static void Main(string[] args)
    {
        Worker worker = new Worker();
        Thread t = new Thread(worker.DoWork);
        t.IsBackground = true;
        t.Start();

        while (true)
        {
            var keyInfo = Console.ReadKey();
            if (keyInfo.Key == ConsoleKey.C && keyInfo.Modifiers == ConsoleModifiers.Control)
            {
                worker.KeepGoing = false;
                break;
            }
        }
        t.Join();
    }
}

class Worker
{
    public bool KeepGoing { get; set; }

    public Worker()
    {
        KeepGoing = true;
    }

    public void DoWork()
    {
        while (KeepGoing)
        {
            Console.WriteLine("Ding");
            Thread.Sleep(200);
        }
    }
}

Também é possível bloquear o thread / programa com base em um token de cancelamento.

token.WaitHandle.WaitOne();

WaitHandle é sinalizado quando o token é cancelado.

Eu vi essa técnica usada pelo Microsoft.Azure.WebJobs.JobHost, onde o token vem de uma fonte de token de cancelamento do WebJobsShutdownWatcher (um inspetor de arquivo que encerra o trabalho).

Isso dá algum controle sobre quando o programa pode terminar.

Dos dois primeiros um é melhor

_quitEvent.WaitOne();

porque no segundo a thread acorda a cada milissegundo e vai para a interrupção do sistema operacional que é cara

Você deve fazer isso como faria se estivesse programando um serviço do Windows. Você nunca usaria uma instrução while, em vez de usar um delegado. WaitOne () é geralmente usado enquanto espera os threads descartar - Thread.Sleep () - não é aconselhável - Você já pensou em usar System.Timers.Timer usando esse evento para verificar o evento de desligamento?