我希望能够在 C# 控制台应用程序中捕获 Ctrl+C，以便在退出之前进行一些清理。最好的方法是什么？

我希望能够在 C# 控制台应用程序中捕获Ctrl+C，以便在退出之前进行一些清理。最好的方法是什么？

我正在使用干净的架构和 FinBuckle 7.0.1 创建多租户 API。我的单元测试运行良好，我可以在客户端标头中设置租户标识符的功能测试也运行良好，

我使用干净的架构和 FinBuckle 7.0.1 创建了一个多租户 API。我的单元测试运行良好，并且我可以在客户端标头中设置租户标识符的功能测试也运行良好，但是，我无法运行集成测试，因为 AppDbContext 中的 tenantinfo 实例始终为空。在测试设置期间，我在 docker 中启动了一个新的 SQL 服务器，构建并使用测试数据填充数据库，DbContext 可以正常工作。但在测试执行期间，tenantindo 始终为空。

是否有人成功创建了通过 WebApplicationFactory '注入'租户的集成测试？

我已经尝试了好几天，并使用了在网上能找到的所有建议，甚至使用了静态租户，但是在测试运行时，AppDbContext 中的租户实例总是为空。

如有任何建议我将不胜感激。

您可以使用 TaskCompletionSource 将转换 Console.CancelKeyPress 为 Task 可直接等待的：

private static Task GetConsoleCancelKeyPressTask()
{
    var taskCompletionSource = new TaskCompletionSource();

    Console.CancelKeyPress += (sender, eventArgs) =>
    {
        // We handled this event, nobody else should do stuff.
        eventArgs.Cancel = true;

        Console.WriteLine("Cancellation requested...");
        taskCompletionSource.SetResult();
    };

    // This will "resolve" when the 'SetResult' method is called.
    return taskCompletionSource.Task;
}

Console.TreatControlCAsInput = true; 对我有用。

我可以在退出之前进行一些清理。最好的方法是什么？这就是真正的目标：陷阱退出，制作你自己的东西。而且上面的答案都没有做对。因为，Ctrl+C 只是退出应用程序的众多方法之一。

在 dotnet c# 中需要什么 - 所谓的 取消令牌 传递给 Host.RunAsync(ct) 然后，在退出信号陷阱中，对于 Windows 来说，它将是

    private static readonly CancellationTokenSource cts = new CancellationTokenSource();
    public static int Main(string[] args)
    {
        // For gracefull shutdown, trap unload event
        AppDomain.CurrentDomain.ProcessExit += (sender, e) =>
        {
            cts.Cancel();
            exitEvent.Wait();
        };

        Console.CancelKeyPress += (sender, e) =>
        {
            cts.Cancel();
            exitEvent.Wait();
        };

        host.RunAsync(cts);
        Console.WriteLine("Shutting down");
        exitEvent.Set();
        return 0;
     }

...

这个问题与以下问题非常相似：

捕获控制台退出 C#

以下是我解决这个问题的方法，以及处理用户按下 X 和 Ctrl-C 的情况。请注意 ManualResetEvents 的使用。这将导致主线程进入休眠状态，从而释放 CPU 以在等待退出或清理时处理其他线程。注意：必须在主线程结束时设置 TerminationCompletedEvent。如果不这样做，由于操作系统在终止应用程序时超时，会导致不必要的终止延迟。

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

从 Linux 上的 .NET 6 开始，我可以证明挂钩 ProcessExit 确实有效。如文档所述，这会捕获 SIGTERM。

截至 2022 年，Console.CancelKeyPress 对我来说一直有效。Win11、.NET 6、NativeAOT 编译的应用程序、OutputType = Exe。

我的答案是用 .net core 5 编写的，并测试了 Ubuntu 21.10，这是我的主要操作系统。

不对。本页上写的所有解决方案都无法在 LINUX 上运行。Console.In.Peek()、CurrentDomain.blah blah()、Console.CancelKeyPress() 它们都只在 Windows 中运行，在 linux 中根本不起作用。这听起来可能很简单，但当你的应用程序作为基于控制台的应用程序在容器中运行时，这是一个大问题，因为 kubernetes 必须将其杀死，而不是正常结束它

检测 SIGTERM 和Ctrl+C：

CancellationTokenSource ctSource = new();
CancellationToken ct = ctSource.Token;

void ExitHandler()
{
    // You can add any arbitrary global clean up
    Console.WriteLine("Exiting...");
    ctSource.Cancel();
}

// Assign exit handler to be called when the process is terminated
// or the user hits CTRL+C
AppDomain.CurrentDomain.ProcessExit += (sender, args) => ExitHandler();
Console.CancelKeyPress += (sender, args) => ExitHandler();

// Then you can use the cancellation token to check for exit:
Console.WriteLine("Ready to gracefully shut down!");
while (!ct.IsCancellationRequested)
{
    Console.WriteLine($"Exit not detected, waiting another 10s.");
    Task.Delay(10000, ct).Wait(ct);
}

我之所以喜欢这个，是因为这是唯一一个能给出完整答案的答案。这个答案很全面，可以让你在任务调度程序下运行程序，而无需用户参与。你仍然有机会进行清理。在你的项目中使用 NLOG，你就有了一些可管理的东西。我想知道它是否会在 .NET Core 2 或 3 中编译。

这是一个完整的工作示例。粘贴到空的 C# 控制台项目中：

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

如果 Main 函数被 Console.ReadLine 暂停，则 Ctrl + C 将向其传递一个空字符串。如果 Main 执行清理并在 Read 之后返回，则会导致并发问题，有人知道如何解决这个问题吗？这需要同步两个线程的状态比较和定义的功能，正确的实现方法是什么？

请注意，虽然在 VS 调试控制台窗口中按 Ctrl-C 时会调用 CancelKeyPress 事件处理程序，但设置 Cancel = true 没有任何效果。

@pkr298 - 很遗憾人们没有投票支持你的评论，因为这是完全正确的。我会编辑 Jonas 的回答，以澄清人们的想法与 Jonathon 的想法不同（这本身并不坏，但 Jonas 的回答并非如此）

我认为关键在于您将在 while 循环内完成所有工作，并且按 Ctrl+C 不会在 while 迭代中间中断；它会在中断之前完成该迭代。

我想补充一下 Jonas 的回答 。旋转 bool CTRLC+时浪费大量能源.

更好的解决方案是使用 ManualResetEvent 来实际“等待”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();
}

注意 - CancelKeyPress 事件是在线程池线程上处理的，这不是很明显：learn.microsoft.com/en-us/dotnet/api/...