Wie kann ich die trap-ctrl-c (SIGINT) in einer C# - Konsolenanwendung

Siehe MSDN:

Console.CancelKeyPress Veranstaltung

Artikel mit code-Beispielen:

Strg-C und der .NET-Konsolenanwendung

Möchte ich hinzufügen Jonas' Antwort. Spinning auf einem bool verursachen 100% CPU-Auslastung, und verschwenden jede Menge Energie tun viel nichts während der Wartezeit für STRG+C.

Die bessere Lösung ist die Verwendung eines ManualResetEvent tatsächlich "warten" für die STRG+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();
}

Diese Frage ist sehr ähnlich:

Capture console exit C#

Hier ist, wie ich dieses problem gelöst, und befasste sich mit der Benutzer zu schlagen, die X sowie Strg-C. Beachten Sie die Verwendung von ManualResetEvents. Diese Ursache wird der main-thread schlafen, die befreit die CPU zu verarbeiten, andere threads während der Wartezeit entweder zu beenden, oder zu bereinigen. HINWEIS: Es ist notwendig, um die TerminationCompletedEvent am Ende von main. Nichtbeachtung führt zu einer unnötigen Wartezeit die Kündigung aufgrund der OS-timing aus, während die Tötung der Anwendung.

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