¿Cómo mantener funcionando una aplicación de consola .NET?

Considere una aplicación de consola que inicia algunos servicios en un hilo separado. Todo lo que necesita hacer es esperar a que el usuario presione Ctrl + C para apagarlo.

¿Cuál de las siguientes es la mejor manera de hacer esto?

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 esto, 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
}

siempre desea evitar el uso de bucles while, especialmente cuando obliga al código a volver a verificar las variables. Desperdicia los recursos de la CPU y ralentiza su programa.

Definitivamente diría el primero.

Alternativamente, una solución más simple es simplemente:

Console.ReadLine();

Puede hacer eso (y eliminar el CancelKeyPresscontrolador de eventos):

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

No estoy seguro si eso es mejor, pero no me gusta la idea de llamar Thread.Sleepen un bucle ... Creo que es más limpio bloquear la entrada del usuario.

Prefiero usar Application.Run

static void Main(string[] args) {

   //Do your stuff here

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

   //Cleanup/Before Quit
}

de los documentos:

Comienza a ejecutar un bucle de mensajes de aplicación estándar en el hilo actual, sin un formulario.

Parece que lo estás poniendo más difícil de lo necesario. ¿Por qué no solo Joinel hilo después de haber señalado que se detenga?

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

También es posible bloquear el hilo / programa basándose en un token de cancelación.

token.WaitHandle.WaitOne();

WaitHandle se señala cuando se cancela el token.

He visto esta técnica utilizada por Microsoft.Azure.WebJobs.JobHost, donde el token proviene de una fuente de token de cancelación de WebJobsShutdownWatcher (un observador de archivos que finaliza el trabajo).

Esto le da cierto control sobre cuándo puede finalizar el programa.

De los dos el primero es mejor

_quitEvent.WaitOne();

porque en el segundo, el hilo se despierta cada milisegundo y se convertirá en una interrupción del sistema operativo, que es costosa

Debe hacerlo como lo haría si estuviera programando un servicio de Windows. Nunca usarías una declaración while en lugar de eso, usarías un delegado. WaitOne () generalmente se usa mientras se espera que los hilos se eliminen - Thread.Sleep () - no es aconsejable - ¿Ha pensado en usar System.Timers.Timer usando ese evento para verificar el evento de apagado?