Come mantenere in esecuzione un'app per console .NET?

Considera un'applicazione console che avvia alcuni servizi in un thread separato. Tutto quello che deve fare è aspettare che l'utente prema Ctrl + C per spegnerlo.

Quale dei seguenti è il modo migliore per farlo?

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
}

O questo, 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
}

si desidera sempre evitare di utilizzare i cicli while, specialmente quando si forza il codice a ricontrollare le variabili. Spreca risorse della CPU e rallenta il programma.

Direi sicuramente il primo.

In alternativa, una soluzione più semplice è semplicemente:

Console.ReadLine();

Puoi farlo (e rimuovere il CancelKeyPressgestore di eventi):

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

Non sono sicuro che sia meglio, ma non mi piace l'idea di chiamare Thread.Sleepin loop .. Penso che sia più pulito bloccare l'input dell'utente.

Preferisco usare Application.Run

static void Main(string[] args) {

   //Do your stuff here

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

   //Cleanup/Before Quit
}

dai documenti:

Inizia l'esecuzione di un ciclo di messaggi dell'applicazione standard sul thread corrente, senza un modulo.

Sembra che tu lo stia rendendo più difficile del necessario. Perché non solo Joinil thread dopo che hai segnalato di fermarsi?

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

È anche possibile bloccare il thread / programma in base a un token di annullamento.

token.WaitHandle.WaitOne();

WaitHandle viene segnalato quando il token viene annullato.

Ho visto questa tecnica utilizzata da Microsoft.Azure.WebJobs.JobHost, in cui il token proviene da un'origine del token di annullamento del WebJobsShutdownWatcher (un file watcher che termina il lavoro).

Questo dà un certo controllo su quando il programma può terminare.

Delle due la prima è migliore

_quitEvent.WaitOne();

perché nel secondo il thread si sveglia ogni millisecondo verrà trasformato in interrupt del sistema operativo che è costoso

Dovresti farlo proprio come faresti se stessi programmando un servizio Windows. Non useresti mai un'istruzione while invece useresti un delegato. WaitOne () viene generalmente utilizzato in attesa che i thread vengano eliminati - Thread.Sleep () - non è consigliabile - Hai pensato di utilizzare System.Timers.Timer utilizzando quell'evento per verificare la presenza di eventi di arresto?