Comment maintenir une application console .NET en cours d'exécution?

Considérez une application console qui démarre certains services dans un thread distinct. Tout ce qu'il faut faire est d'attendre que l'utilisateur appuie sur Ctrl + C pour l'arrêter.

Laquelle des propositions suivantes est la meilleure façon de procéder?

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 ceci, en utilisant 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
}

vous voulez toujours éviter d'utiliser des boucles while, en particulier lorsque vous forcez le code à revérifier les variables. Cela gaspille les ressources du processeur et ralentit votre programme.

Je dirais certainement le premier.

Alternativement, une solution plus simple est simplement:

Console.ReadLine();

Vous pouvez le faire (et supprimer le CancelKeyPressgestionnaire d'événements):

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

Je ne sais pas si c'est mieux, mais je n'aime pas l'idée d'appeler Thread.Sleepen boucle .. Je pense que c'est plus propre de bloquer les entrées de l'utilisateur.

Je préfère utiliser l' application.

static void Main(string[] args) {

   //Do your stuff here

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

   //Cleanup/Before Quit
}

à partir de la documentation:

Commence à exécuter une boucle de message d'application standard sur le thread actuel, sans formulaire.

On dirait que vous rendez les choses plus difficiles que nécessaire. Pourquoi pas juste Joinle fil après que vous lui avez signalé de s'arrêter?

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

Il est également possible de bloquer le thread / programme en fonction d'un jeton d'annulation.

token.WaitHandle.WaitOne();

WaitHandle est signalé lorsque le jeton est annulé.

J'ai vu cette technique utilisée par Microsoft.Azure.WebJobs.JobHost, où le jeton provient d'une source de jeton d'annulation de WebJobsShutdownWatcher (un observateur de fichiers qui met fin au travail).

Cela donne un certain contrôle sur la fin du programme.

Des deux, le premier est meilleur

_quitEvent.WaitOne();

parce que dans le second, le thread se réveille toutes les millisecondes sera transformé en interruption du système d'exploitation qui coûte cher

Vous devez le faire comme vous le feriez si vous programmiez un service Windows. Vous n'utiliseriez jamais une instruction while à la place, vous utiliseriez un délégué. WaitOne () est généralement utilisé en attendant que les threads se débarrassent - Thread.Sleep () - n'est pas conseillé - Avez-vous pensé à utiliser System.Timers.Timer en utilisant cet événement pour vérifier l'événement d'arrêt?