Comment garder un .NET console application en cours d'exécution?

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

Laquelle des affirmations suivantes est la meilleure façon de le faire?

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 cela, à l'aide de Fil.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
}

InformationsquelleAutor intoOrbit | 2010-04-06

c#manualresetevent multithreading sleep

60

vous voulez toujours de prévenir l'utilisation des boucles while, surtout quand vous êtes en forçant le code de vérification des variables. Il gaspille les ressources CPU et ralentit votre programme.

Je n'hésiterais pas à dire que la première.
- +1. En outre, depuis le bool n'est pas déclaré comme volatile, il y a la possibilité réelle que les lectures suivantes pour _quitFlag dans le while boucle serait optimisé loin, conduisant à une boucle infinie.
- Manquant de la manière recommandée pour ce faire. Je m'attendais à ce qu'une réponse.
InformationsquelleAutor Mike
27

Sinon, une solution plus simple est juste:
```
Console.ReadLine();
```
- J'étais sur le point de suggérer que, mais il ne s'arrêtera pas uniquement sur Ctrl-C
- J'ai eu l'impression que CTRL-C était juste un exemple - toute entrée d'utilisateur pour le fermer
- Rappelez-vous que " de la Console.ReadLine()' est le blocage du thread. De sorte que l'application devrait toujours être en cours d'exécution, mais ne rien faire que d'attendre à l'utilisateur d'entrer une ligne de
- L'OP question des états coup d'envoi asynchrone trucs", de sorte que la demande sera effectuer un travail sur un autre thread
- J'ai manqué. Mon mauvais!
- Ce que je viens de reconnu, c'est qu'avec une Console.ReadLine à la fin de la main, l'application s'arrête immédiatement et peut-être de ne pas exécuter le code dans l'événement cancelkeypress-fonction
- Console.ReadLine a été une source d'une longue mystère pour nous. Elle a contribué à une impasse lorsqu'il est utilisé conjointement avec Console.WriteLine. Ce qui se passerait lorsqu'on clique sur la fenêtre de la console de telle manière que la console attendu pour l'entrée.
InformationsquelleAutor Cocowalla
13

Vous pouvez le faire (et supprimer le CancelKeyPress gestionnaire d'événement) :
```
while(!_quitFlag)
{
    var keyInfo = Console.ReadKey();
    _quitFlag = keyInfo.Key == ConsoleKey.C
             && keyInfo.Modifiers == ConsoleModifiers.Control;
}
```
Ne sais pas si c'est mieux, mais je n'aime pas l'idée d'appeler Thread.Sleep dans une boucle.. je pense que c'est plus propre à bloquer sur la saisie de l'utilisateur.
- Je n'aime pas que vous êtes à vérifier les touches Ctrl+C, au lieu de le signal déclenché par Ctrl+C.
InformationsquelleAutor Thomas Levesque
9

Je préfère utiliser les Application.Exécuter
```
static void Main(string[] args) {

   //Do your stuff here

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

   //Cleanup/Before Quit
}
```
de la documentation:

Commence l'exécution d'une application standard boucle de message sur le thread en cours, sans une forme.
- Mais ensuite, vous prenez une dépendance sur les windows forms juste pour cela. Pas trop un problème avec le traditionnel .NET framework, mais la tendance actuelle est vers modulaire des déploiements, y compris seulement les pièces dont vous avez besoin.
InformationsquelleAutor ygaradon

Semble que vous êtes en rendant plus difficile que vous en avez besoin. Pourquoi ne pas simplement Join le fil après que vous avez signalé il 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);
        }
    }
}

Dans mon cas, je n'ai pas de contrôle sur les threads que l'asynchrone choses s'exécute sur.
1) je n'aime pas que vous êtes à vérifier les touches Ctrl+C, au lieu de le signal déclenché par Ctrl+C. 2) Votre approche ne fonctionne pas si l'application utilise des Tâches au lieu d'un seul thread de travail.

InformationsquelleAutor Ed Power

2

Des deux premiers est le meilleur
```
_quitEvent.WaitOne();
```
parce que dans le second, le fil se réveille chaque milliseconde obtiendrez transformé en OS interruption qui est cher
- C'est une bonne alternative pour Console méthodes si vous n'avez pas de console ci-joint (en raison, par exemple, le programme est démarré par un service)
InformationsquelleAutor Naveen
0

Vous devriez faire exactement comme vous le feriez si vous étiez de la programmation d'un service windows. Vous de ne jamais utiliser une instruction while au lieu de cela, vous utilisez un délégué. WaitOne() est généralement utilisé lors de l'attente pour les threads de disposer - Fil.Sleep() - n'est pas advisible - Avez-vous pensé à utiliser le Système.Les minuteries.Minuterie à l'aide de cet événement à vérifier par l'arrêt de l'événement?

InformationsquelleAutor KenL
0

Il est également possible de bloquer le thread /programme basé sur un jeton d'annulation.
```
token.WaitHandle.WaitOne();
```
WaitHandle est signalée lorsque le jeton est annulée.

J'ai vu cette technique utilisée par Microsoft.Azure.WebJobs.JobHost, où le jeton provient d'une source de jeton d'annulation de la WebJobsShutdownWatcher (un fichier watcher que la fin de la tâche).

Cela donne un certain contrôle sur le moment où le programme peut se terminer.

InformationsquelleAutor CRice

Vous devez vous connecter pour publier un commentaire.