Tangkap keluar konsol C #

Saya memiliki aplikasi konsol yang berisi cukup banyak utas. Ada utas yang memantau kondisi tertentu dan menghentikan program jika benar. Penghentian ini bisa terjadi kapan saja.

Saya memerlukan acara yang dapat dipicu saat program ditutup sehingga saya dapat membersihkan semua utas lainnya dan menutup semua pegangan file dan koneksi dengan benar. Saya tidak yakin apakah sudah ada yang dibangun ke dalam kerangka .NET, jadi saya bertanya sebelum saya menulisnya sendiri.

Saya bertanya-tanya apakah ada acara di sepanjang baris:

MyConsoleProgram.OnExit += CleanupBeforeExit;

Saya tidak yakin di mana saya menemukan kode di web, tetapi sekarang saya menemukannya di salah satu proyek lama saya. Ini akan memungkinkan Anda untuk melakukan kode pembersihan di konsol Anda, misalnya ketika tiba-tiba ditutup atau karena shutdown ...

[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:
      default:
          return false;
  }
}


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

Memperbarui

Bagi mereka yang tidak memeriksa komentar, tampaknya solusi khusus ini tidak berfungsi dengan baik (atau sama sekali) di Windows 7 . Utas berikut berbicara tentang ini

Contoh kerja penuh, bekerja dengan ctrl-c, menutup jendela dengan X dan mematikan:

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

Periksa juga:

AppDomain.CurrentDomain.ProcessExit

Saya memiliki masalah serupa, hanya Aplikasi konsol saya yang akan berjalan dalam putaran tak terbatas dengan satu pernyataan preemptive di tengah. Inilah solusi saya:

class Program
{
    static int Main(string[] args)
    {
        // Init Code...
        Console.CancelKeyPress += Console_CancelKeyPress;  // Register the function to cancel event

        // I do my stuffs

        while ( true )
        {
            // Code ....
            SomePreemptiveCall();  // The loop stucks here wating function to return
            // Code ...
        }
        return 0;  // Never comes here, but...
    }

    static void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
    {
        Console.WriteLine("Exiting");
        // Termitate what I have to terminate
        Environment.Exit(-1);
    }
}

Sepertinya Anda memiliki utas yang langsung menghentikan aplikasi? Mungkin akan lebih baik jika thread memberi sinyal pada thread utama untuk mengatakan bahwa aplikasi tersebut harus dihentikan.

Saat menerima sinyal ini, utas utama dapat mematikan utas lainnya dengan bersih dan akhirnya menutup sendiri.

Jawaban ZeroKelvin berfungsi di aplikasi konsol Windows 10 x64, .NET 4.6. Bagi mereka yang tidak perlu berurusan dengan CtrlType enum, berikut adalah cara yang sangat sederhana untuk menghubungkan ke shutdown framework:

class Program
{
    private delegate bool ConsoleCtrlHandlerDelegate(int sig);

    [DllImport("Kernel32")]
    private static extern bool SetConsoleCtrlHandler(ConsoleCtrlHandlerDelegate handler, bool add);

    static ConsoleCtrlHandlerDelegate _consoleCtrlHandler;

    static void Main(string[] args)
    {
        _consoleCtrlHandler += s =>
        {
            //DoCustomShutdownStuff();
            return false;   
        };
        SetConsoleCtrlHandler(_consoleCtrlHandler, true);
    }
}

Mengembalikan FALSE dari penangan memberi tahu kerangka kerja bahwa kita tidak "menangani" sinyal kontrol, dan fungsi penangan berikutnya dalam daftar penangan untuk proses ini digunakan. Jika tidak ada penangan yang mengembalikan TRUE, penangan default dipanggil.

Perhatikan bahwa ketika pengguna melakukan logoff atau shutdown, callback tidak dipanggil oleh Windows tetapi dihentikan segera.

Ada untuk aplikasi WinForms;

Application.ApplicationExit += CleanupBeforeExit;

Untuk aplikasi Konsol, coba

AppDomain.CurrentDomain.DomainUnload += CleanupBeforeExit;

Tetapi saya tidak yakin pada poin apa yang dipanggil atau apakah itu akan berfungsi dari dalam domain saat ini. Saya kira tidak.

Visual Studio 2015 + Windows 10

• Izinkan untuk pembersihan
• Aplikasi instance tunggal
• Beberapa lempengan emas

Kode:

using System;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;

namespace YourNamespace
{
    class Program
    {
        // if you want to allow only one instance otherwise remove the next line
        static Mutex mutex = new Mutex(false, "YOURGUID-YOURGUID-YOURGUID-YO");

        static ManualResetEvent run = new ManualResetEvent(true);

        [DllImport("Kernel32")]
        private static extern bool SetConsoleCtrlHandler(EventHandler handler, bool add);                
        private delegate bool EventHandler(CtrlType sig);
        static EventHandler exitHandler;
        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 ExitHandler(CtrlType sig)
        {
            Console.WriteLine("Shutting down: " + sig.ToString());            
            run.Reset();
            Thread.Sleep(2000);
            return false; // If the function handles the control signal, it should return TRUE. If it returns FALSE, the next handler function in the list of handlers for this process is used (from MSDN).
        }


        static void Main(string[] args)
        {
            // if you want to allow only one instance otherwise remove the next 4 lines
            if (!mutex.WaitOne(TimeSpan.FromSeconds(2), false))
            {
                return; // singleton application already started
            }

            exitHandler += new EventHandler(ExitHandler);
            SetConsoleCtrlHandler(exitHandler, true);

            try
            {
                Console.BackgroundColor = ConsoleColor.Gray;
                Console.ForegroundColor = ConsoleColor.Black;
                Console.Clear();
                Console.SetBufferSize(Console.BufferWidth, 1024);

                Console.Title = "Your Console Title - XYZ";

                // start your threads here
                Thread thread1 = new Thread(new ThreadStart(ThreadFunc1));
                thread1.Start();

                Thread thread2 = new Thread(new ThreadStart(ThreadFunc2));
                thread2.IsBackground = true; // a background thread
                thread2.Start();

                while (run.WaitOne(0))
                {
                    Thread.Sleep(100);
                }

                // do thread syncs here signal them the end so they can clean up or use the manual reset event in them or abort them
                thread1.Abort();
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.Write("fail: ");
                Console.ForegroundColor = ConsoleColor.Black;
                Console.WriteLine(ex.Message);
                if (ex.InnerException != null)
                {
                    Console.WriteLine("Inner: " + ex.InnerException.Message);
                }
            }
            finally
            {                
                // do app cleanup here

                // if you want to allow only one instance otherwise remove the next line
                mutex.ReleaseMutex();

                // remove this after testing
                Console.Beep(5000, 100);
            }
        }

        public static void ThreadFunc1()
        {
            Console.Write("> ");
            while ((line = Console.ReadLine()) != null)
            {
                if (line == "command 1")
                {

                }
                else if (line == "command 1")
                {

                }
                else if (line == "?")
                {

                }

                Console.Write("> ");
            }
        }


        public static void ThreadFunc2()
        {
            while (run.WaitOne(0))
            {
                Thread.Sleep(100);
            }

           // do thread cleanup here
            Console.Beep();         
        }

    }
}

The Link yang disebutkan di atas oleh Charle B dalam komentar untuk flq

Jauh di lubuk hatinya mengatakan:

SetConsoleCtrlHandler tidak akan berfungsi di windows7 jika Anda menautkan ke user32

Beberapa tempat lain di utas disarankan untuk membuat jendela tersembunyi. Jadi saya membuat winform dan dalam onload saya terpasang ke konsol dan menjalankan Main asli. Dan kemudian SetConsoleCtrlHandle berfungsi dengan baik (SetConsoleCtrlHandle dipanggil seperti yang disarankan oleh flq)

public partial class App3DummyForm : Form
{
    private readonly string[] _args;

    public App3DummyForm(string[] args)
    {
        _args = args;
        InitializeComponent();
    }

    private void App3DummyForm_Load(object sender, EventArgs e)
    {
        AllocConsole();
        App3.Program.OriginalMain(_args);
    }

    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    static extern bool AllocConsole();
}

Bagi yang tertarik dengan VB.net. (Saya mencari di internet dan tidak dapat menemukan padanan untuk itu) Ini diterjemahkan ke dalam vb.net.

    <DllImport("kernel32")> _
    Private Function SetConsoleCtrlHandler(ByVal HandlerRoutine As HandlerDelegate, ByVal Add As Boolean) As Boolean
    End Function
    Private _handler As HandlerDelegate
    Private Delegate Function HandlerDelegate(ByVal dwControlType As ControlEventType) As Boolean
    Private Function ControlHandler(ByVal controlEvent As ControlEventType) As Boolean
        Select Case controlEvent
            Case ControlEventType.CtrlCEvent, ControlEventType.CtrlCloseEvent
                Console.WriteLine("Closing...")
                Return True
            Case ControlEventType.CtrlLogoffEvent, ControlEventType.CtrlBreakEvent, ControlEventType.CtrlShutdownEvent
                Console.WriteLine("Shutdown Detected")
                Return False
        End Select
    End Function
    Sub Main()
        Try
            _handler = New HandlerDelegate(AddressOf ControlHandler)
            SetConsoleCtrlHandler(_handler, True)
     .....
End Sub