Przechwyć wyjście konsoli C# w systemie Windows 7

Question

Czy ktoś wie, jak reagować na zdarzenie ctrl + cw konsoli w C# w oknach?

to pytanie: Capture console exit C# mówi, jak to zrobić, ale próbowałem i przechwytuje tylko zdarzenie, gdy użytkownik kliknie przycisk Zamknij X w górnej części okna konsoli.

Nic się nie dzieje, gdy użytkownik wpisze ctrl + c, nawet nie trafi do programu obsługi podczas debugowania.

Dzięki

Oto mój kod

namespace EventCloseConsole 
{ 
    using System.Runtime.InteropServices; 
    using System; 

    class Program 
    { 
     [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) 
     { 
      switch (sig) 
      { 
       case CtrlType.CTRL_C_EVENT: 
       case CtrlType.CTRL_LOGOFF_EVENT: 
       case CtrlType.CTRL_SHUTDOWN_EVENT: 
       case CtrlType.CTRL_CLOSE_EVENT: 

        Console.WriteLine("Closing"); 
        System.Threading.Thread.Sleep(500); 
        return false; 
       default: 
        return true; 
      } 
     } 

     static void Main(string[] args) 
     { 

      _handler += new EventHandler(Handler); 
      SetConsoleCtrlHandler(_handler, true); 
      Console.ReadLine(); 


     } 
    } 
} 

Answer 1

Trzeba drut zdarzenie Console.CancelKeyPress do obsługi. Here to świetny artykuł na ten temat.

Answer 2

To działa dla mnie na Windows 7. Zamknięcie z X-przycisk
tajemnica jest zmienna statyczna ConsoleEventDelegate _D

private static void Main(string[] args) 
{ 
    ConsoleEventHooker.Closed += ConsoleEventHooker_Closed; 
} 

static void ConsoleHooker_Closed(object sender, EventArgs e) 
{ 
} 

ConsoleEventHooker.cs

namespace System 
{ 
    internal static class ConsoleEventHooker 
    { 
     private static bool _initedHooker; 
     private static EventHandler _closed; 
     private static EventHandler _shutdown; 
     private static ConsoleEventDelegate _d; 

     public static event EventHandler Closed 
     { 
      add 
      { 
       Init(); 
       _closed += value; 
      } 
      remove { _closed -= value; } 
     } 

     public static event EventHandler Shutdown 
     { 
      add 
      { 
       Init(); 
       _shutdown += value; 
      } 
      remove { _shutdown -= value; } 
     } 

     private static void Init() 
     { 
      if (_initedHooker) return; 
      _initedHooker = true; 
      _d = ConsoleEventCallback; 
      SetConsoleCtrlHandler(_d, true); 
     } 

     private static bool ConsoleEventCallback(CtrlTypes eventType) 
     { 
      if (eventType == CtrlTypes.CTRL_CLOSE_EVENT) 
      { 
       if(_closed != null) _closed(null,new EventArgs()); 
      } 

      if (eventType == CtrlTypes.CTRL_SHUTDOWN_EVENT) 
      { 
       if (_shutdown != null) _shutdown(null, new EventArgs()); 
      } 
      return false; 
     } 

     // A delegate type to be used as the handler routine 
     // for SetConsoleCtrlHandler. 
     delegate bool ConsoleEventDelegate(CtrlTypes ctrlType); 

     [DllImport("kernel32.dll", SetLastError = true)] 
     private static extern bool SetConsoleCtrlHandler(ConsoleEventDelegate callback, bool add); 

    } 

    // An enumerated type for the control messages 
    // sent to the handler routine. 
    public enum CtrlTypes 
    { 
     CTRL_C_EVENT = 0, 
     CTRL_BREAK_EVENT, 
     CTRL_CLOSE_EVENT, 
     CTRL_LOGOFF_EVENT = 5, 
     CTRL_SHUTDOWN_EVENT 
    }