Comment puis-je recouvrir ctrl-c (SIGINT) dans une console C# app

Voir MSDN:

Console.Événement Cancelkeypress

Article avec des exemples de code:

Ctrl-C et de l' .NET application console

Je voudrais ajouter à Jonas répondre. Filer sur un bool sera la cause de l'UC à 100%, et un tas de déchets de l'énergie en faisant beaucoup de rien en attendant CTRL+C.

La meilleure solution est d'utiliser un ManualResetEvent à fait "attendre" pour 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();
}

Cette question est très similaire à:

La Capture de la sortie de la console en C#

Voici comment j'ai résolu ce problème, et traitées à l'utilisateur de frapper le X et Ctrl-C. Notez l'utilisation de ManualResetEvents. Ces provoquera le thread principal pour dormir, ce qui libère le CPU pour le traitement d'autres threads en attendant la sortie, ou le nettoyage. REMARQUE: Il est nécessaire de définir la TerminationCompletedEvent à la fin de la main. Le manque de faire ainsi, inutile de latence en rupture due à l'OS d'expirer 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;
}
}
}