Comment piéger ctrl-c (SIGINT) dans une application console C #


222

Je voudrais pouvoir piéger CTRL+ Cdans une application console C # afin de pouvoir effectuer quelques nettoyages avant de quitter. Quelle est la meilleure façon de procéder?

Réponses:


127

Voir MSDN:

Console.CancelKeyPress, événement

Article avec des exemples de code:

Ctrl-C et l'application console .NET


6
En fait, cet article recommande P / Invoke et CancelKeyPressn'est mentionné que brièvement dans les commentaires. Un bon article est codeneverwritten.com/2006/10/…
bzlm

Cela fonctionne mais il ne piège pas la fermeture de la fenêtre avec le X. Voir ma solution complète ci-dessous. fonctionne aussi avec kill
JJ_Coder4Hire

1
J'ai constaté que cette Console.CancelKeyPress cessera de fonctionner si la console est fermée. Exécuter une application sous mono / linux avec systemd, ou si l'application est exécutée en tant que "mono myapp.exe </ dev / null", un SIGINT sera envoyé au gestionnaire de signal par défaut et tuera instantanément l'application. Les utilisateurs de Linux voudront peut-être voir stackoverflow.com/questions/6546509/…
tekHedd

2
Lien non rompu pour le commentaire de @ bzlm: web.archive.org/web/20110424085511/http://…
Ian Kemp

@aku n'y a-t-il pas suffisamment de temps pour répondre au SIGINT avant que le processus ne soit brutalement interrompu? Je ne le trouve nulle part et j'essaie de me rappeler où je l'ai lu.
John Zabroski

224

L' événement Console.CancelKeyPress est utilisé pour cela. Voici comment il est utilisé:

public static void Main(string[] args)
{
    Console.CancelKeyPress += delegate {
        // call methods to clean up
    };

    while (true) {}
}

Lorsque l'utilisateur appuie sur Ctrl + C, le code dans le délégué est exécuté et le programme se ferme. Cela vous permet d'effectuer un nettoyage en appelant les méthodes nécessaires. Notez qu'aucun code après l'exécution du délégué.

Il y a d'autres situations où cela ne suffira pas. Par exemple, si le programme effectue actuellement des calculs importants qui ne peuvent pas être immédiatement arrêtés. Dans ce cas, la bonne stratégie pourrait être de dire au programme de quitter une fois le calcul terminé. Le code suivant donne un exemple de la façon dont cela peut être implémenté:

class MainClass
{
    private static bool keepRunning = true;

    public static void Main(string[] args)
    {
        Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e) {
            e.Cancel = true;
            MainClass.keepRunning = false;
        };

        while (MainClass.keepRunning) {
            // Do your work in here, in small chunks.
            // If you literally just want to wait until ctrl-c,
            // not doing anything, see the answer using set-reset events.
        }
        Console.WriteLine("exited gracefully");
    }
}

La différence entre ce code et le premier exemple est qu'il e.Cancelest défini sur true, ce qui signifie que l'exécution se poursuit après le délégué. S'il est exécuté, le programme attend que l'utilisateur appuie sur Ctrl + C. Lorsque cela se produit, la keepRunningvariable change de valeur, ce qui provoque la sortie de la boucle while. C'est une façon de faire sortir le programme avec élégance.


21
keepRunningpeut avoir besoin d'être marqué volatile. Sinon, le thread principal peut le mettre en cache sur un registre CPU et ne remarquera pas la modification de la valeur lorsque le délégué est exécuté.
cdhowie

Cela fonctionne mais il ne piège pas la fermeture de la fenêtre avec le X. Voir ma solution complète ci-dessous. fonctionne aussi avec kill.
JJ_Coder4Hire

13
Doit être modifié pour utiliser un ManualResetEventplutôt que de tourner sur un bool.
Mizipzor

Une petite mise en garde pour quiconque exécute des trucs en cours d'exécution dans Git-Bash, MSYS2 ou CygWin: Vous devrez exécuter dotnet via winpty pour que cela fonctionne (donc, winpty dotnet run). Sinon, le délégué ne sera jamais exécuté.
Samuel Lampa

Attention, l'événement pour CancelKeyPress est géré sur un thread de pool de threads, ce qui n'est pas immédiatement évident: docs.microsoft.com/en-us/dotnet/api/…
Sam Rueby

100

Je voudrais ajouter à la réponse de Jonas . Tourner sur un boolentraînera une utilisation de 100% du processeur et gaspillera beaucoup d'énergie sans rien faire en attendant CTRL+ C.

La meilleure solution consiste à utiliser un ManualResetEventpour "attendre" le CTRL+ C:

static void Main(string[] args) {
    var exitEvent = new ManualResetEvent(false);

    Console.CancelKeyPress += (sender, eventArgs) => {
                                  eventArgs.Cancel = true;
                                  exitEvent.Set();
                              };

    var server = new MyServer();     // example
    server.Run();

    exitEvent.WaitOne();
    server.Stop();
}

28
Je pense que le fait est que vous feriez tout le travail à l'intérieur de la boucle while, et que Ctrl + C ne se cassera pas au milieu de l'itération while; il terminera cette itération avant de se déclencher.
pkr298

2
@ pkr298 - Dommage que les gens ne votent pas votre commentaire car c'est tout à fait vrai. Je vais éditer Jonas sa réponse pour clarifier les gens de penser comme Jonathon (ce qui n'est pas mauvais en soi mais pas comme Jonas voulait dire sa réponse)
M. Mimpen

Mettez à jour la réponse existante avec cette amélioration.
Mizipzor

27

Voici un exemple de travail complet. coller dans un projet de console C # vide:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;

namespace TestTrapCtrlC {
    public class Program {
        static bool exitSystem = false;

        #region Trap application termination
        [DllImport("Kernel32")]
        private static extern bool SetConsoleCtrlHandler(EventHandler handler, bool add);

        private delegate bool EventHandler(CtrlType sig);
        static EventHandler _handler;

        enum CtrlType {
            CTRL_C_EVENT = 0,
            CTRL_BREAK_EVENT = 1,
            CTRL_CLOSE_EVENT = 2,
            CTRL_LOGOFF_EVENT = 5,
            CTRL_SHUTDOWN_EVENT = 6
        }

        private static bool Handler(CtrlType sig) {
            Console.WriteLine("Exiting system due to external CTRL-C, or process kill, or shutdown");

            //do your cleanup here
            Thread.Sleep(5000); //simulate some cleanup delay

            Console.WriteLine("Cleanup complete");

            //allow main to run off
            exitSystem = true;

            //shutdown right away so there are no lingering threads
            Environment.Exit(-1);

            return true;
        }
        #endregion

        static void Main(string[] args) {
            // Some biolerplate to react to close window event, CTRL-C, kill, etc
            _handler += new EventHandler(Handler);
            SetConsoleCtrlHandler(_handler, true);

            //start your multi threaded program here
            Program p = new Program();
            p.Start();

            //hold the console so it doesn’t run off the end
            while (!exitSystem) {
                Thread.Sleep(500);
            }
        }

        public void Start() {
            // start a thread and start doing some processing
            Console.WriteLine("Thread started, processing..");
        }
    }
}

8
ce p / invoque n'est donc pas
multiplateforme

J'ai juste ajouté ceci parce que c'est la seule réponse qui répond à une réponse complète. Celui-ci est complet et vous permet d'exécuter le programme sous le planificateur de tâches sans intervention de l'utilisateur. Vous avez toujours la possibilité de nettoyer. Utilisez NLOG dans votre projet et vous avez quelque chose de gérable. Je me demande si ça va compiler en .NET Core 2 ou 3.
BigTFromAZ

7

Cette question est très similaire à:

Quitter la console de capture C #

Voici comment j'ai résolu ce problème et traité avec l'utilisateur frappant le X ainsi que Ctrl-C. Notez l'utilisation de ManualResetEvents. Cela entraînera la mise en veille du thread principal, ce qui libère le processeur pour traiter d'autres threads en attendant la sortie ou le nettoyage. REMARQUE: Il est nécessaire de définir TerminationCompletedEvent à la fin de main. Ne pas le faire entraîne une latence inutile dans la terminaison en raison de l'expiration du système d'exploitation tout en tuant l'application.

namespace CancelSample
{
    using System;
    using System.Threading;
    using System.Runtime.InteropServices;

    internal class Program
    {
        /// <summary>
        /// Adds or removes an application-defined HandlerRoutine function from the list of handler functions for the calling process
        /// </summary>
        /// <param name="handler">A pointer to the application-defined HandlerRoutine function to be added or removed. This parameter can be NULL.</param>
        /// <param name="add">If this parameter is TRUE, the handler is added; if it is FALSE, the handler is removed.</param>
        /// <returns>If the function succeeds, the return value is true.</returns>
        [DllImport("Kernel32")]
        private static extern bool SetConsoleCtrlHandler(ConsoleCloseHandler handler, bool add);

        /// <summary>
        /// The console close handler delegate.
        /// </summary>
        /// <param name="closeReason">
        /// The close reason.
        /// </param>
        /// <returns>
        /// True if cleanup is complete, false to run other registered close handlers.
        /// </returns>
        private delegate bool ConsoleCloseHandler(int closeReason);

        /// <summary>
        ///  Event set when the process is terminated.
        /// </summary>
        private static readonly ManualResetEvent TerminationRequestedEvent;

        /// <summary>
        /// Event set when the process terminates.
        /// </summary>
        private static readonly ManualResetEvent TerminationCompletedEvent;

        /// <summary>
        /// Static constructor
        /// </summary>
        static Program()
        {
            // Do this initialization here to avoid polluting Main() with it
            // also this is a great place to initialize multiple static
            // variables.
            TerminationRequestedEvent = new ManualResetEvent(false);
            TerminationCompletedEvent = new ManualResetEvent(false);
            SetConsoleCtrlHandler(OnConsoleCloseEvent, true);
        }

        /// <summary>
        /// The main console entry point.
        /// </summary>
        /// <param name="args">The commandline arguments.</param>
        private static void Main(string[] args)
        {
            // Wait for the termination event
            while (!TerminationRequestedEvent.WaitOne(0))
            {
                // Something to do while waiting
                Console.WriteLine("Work");
            }

            // Sleep until termination
            TerminationRequestedEvent.WaitOne();

            // Print a message which represents the operation
            Console.WriteLine("Cleanup");

            // Set this to terminate immediately (if not set, the OS will
            // eventually kill the process)
            TerminationCompletedEvent.Set();
        }

        /// <summary>
        /// Method called when the user presses Ctrl-C
        /// </summary>
        /// <param name="reason">The close reason</param>
        private static bool OnConsoleCloseEvent(int reason)
        {
            // Signal termination
            TerminationRequestedEvent.Set();

            // Wait for cleanup
            TerminationCompletedEvent.WaitOne();

            // Don't run other handlers, just exit.
            return true;
        }
    }
}

3

Console.TreatControlCAsInput = true; a travaillé pour moi.


2
Cela peut obliger ReadLine à nécessiter deux pressions sur Entrée pour chaque entrée.
Grault

0

Je peux effectuer quelques nettoyages avant de quitter. Quelle est la meilleure façon de le faire? C'est le véritable objectif: sortir du piège, faire vos propres trucs. Et les réponses neigther ci-dessus ne le font pas bien. Parce que Ctrl + C n'est qu'une des nombreuses façons de quitter l'application.

Ce qui est nécessaire dans dotnet c # - ce que l'on appelle un jeton d'annulation transmis à Host.RunAsync(ct)puis dans les interruptions de signaux de sortie, pour Windows, il serait

    private static readonly CancellationTokenSource cts = new CancellationTokenSource();
    public static int Main(string[] args)
    {
        // For gracefull shutdown, trap unload event
        AppDomain.CurrentDomain.ProcessExit += (sender, e) =>
        {
            cts.Cancel();
            exitEvent.Wait();
        };

        Console.CancelKeyPress += (sender, e) =>
        {
            cts.Cancel();
            exitEvent.Wait();
        };

        host.RunAsync(cts);
        Console.WriteLine("Shutting down");
        exitEvent.Set();
        return 0;
     }

...

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.