20 thoughts on “Stopping command-line applications programatically with Ctrl-C event from .Net – a working demo”

1. Awesome life saver 🙂 🙂

2. Thank you! Really helpful.

3. You my friend are a fine man indeed. So far so good… worked very first time! If only Id read this 12 hours ago… thank you sir 🙂

4. My god… After 6 hours of trial and error, you had the right answer all along. You’re magnificent and I can’t thank you enough!

5. Sorry here is the complete working example. just paste into a new C# console project and run. hit ctrl-c or X the window out.

   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..");
           }
       }
   }
   

6. Jason Jakob, your solution is similar to my example #4, with the difference that I start a process without a console window, which is desirable when you write a front-end application that takes over the stdout/stderr streams of the child process. My solution is also slightly more robust.

7. Your post helped me.Thanks alot

8. This is great, man. I’ve search to find a solution for hours. I was missing the console attaching.
   Thank you for a very well written article.

9. good job!

10. Pingback: Can I send a ctrl-C (SIGINT) to an application on Windows? - dex page

11. Thank you for your article – it help me a lot.
    The solution #4 work fine for me.

    Unfortunately, sometimes it happens, the process is not exited after Ctrl-C and the application stuck in “process.WaitForExit();”.
    As solution for this, I propose little improvement of your “StopProgramByAttachingToItsConsoleAndIssuingCtrlCEvent” method – to add there timer which (after a specified timeout) kills the process if the process has not exited automatically.

    Here is the updated method:

            private static void StopProgramByAttachingToItsConsoleAndIssuingCtrlCEvent(Process process, int waitForExitTimeout = 2000)
            {
                if (!AttachConsole((uint) process.Id))
                {
                    return;
                }
    
                // Disable Ctrl-C handling for our program
                SetConsoleCtrlHandler(null, true);
    
                // Sent Ctrl-C to the attached console
                GenerateConsoleCtrlEvent(CtrlTypes.CTRL_C_EVENT, 0);
    
                // Wait for the graceful end of the process.
                // If the process will not exit in time specified by 'waitForExitTimeout', the process will be killed
                using (new Timer((dummy => {if (!process.HasExited) process.Kill(); }), null, waitForExitTimeout, Timeout.Infinite))
                {
                    // Must wait here. If we don't wait and re-enable Ctrl-C handling below too fast, we might terminate ourselves.
                    process.WaitForExit();    
                }
    
                FreeConsole();
    
                // Re-enable Ctrl-C handling or any subsequently started programs will inherit the disabled state.
                SetConsoleCtrlHandler(null, false);
            }
    

12. Thank you, Michal. I’ve updated the main post, pointing to your improved solution.

13. Was totally stumped by this issue – really appreciate your taking the time to post it.

14. Pingback: How to get shutdown hook to execute on a process launched from Eclipse - QuestionFocus

15. Pingback: Can I send a ctrl-C (SIGINT) to an application on Windows? - ExceptionsHub

16. Thank you very much… this solved my issue

17. Glad it was of help 🙂

18. I found this helpful post when implementing support for this in the MedallionShell NuGet package (https://github.com/madelson/MedallionShell#stopping-a-command). I ended up using a variant of the console-attach method for the Windows implementation. It tries to handle edge cases like signaling the current process, signaling a process which shares the current process’s console, and signaling from a process which is actively using its console (so we don’t want to detach the current console). The implementation starts here for anyone who is interested: https://github.com/madelson/MedallionShell/blob/master/MedallionShell/Signals/WindowsProcessSignaler.cs Happy to receive any comments or suggestions!

19. Pingback: How to get shutdown hook to execute on a process launched from Eclipse – inneka.com

20. Pingback: Can I send a ctrl-C (SIGINT) to an application on Windows? – inneka.com

Comments are closed.