如何将 ctrl+c 发送到 C# 中的进程？

我正在为命令行可执行文件编写一个包装类。该exe接受来自的输入stdin直到我击中Ctrl+C在命令提示符 shell 中，在这种情况下，它将输出打印到stdout基于输入。我想模拟一下Ctrl+C按 C# 代码，将终止命令发送到 .NETProcess目的。我试过打电话Process.Kill()，但这似乎并没有给我带来任何好处StandardOutput StreamReader。我可能有什么地方做得不对吗？这是我尝试使用的代码：

ProcessStartInfo info = new ProcessStartInfo(exe, args);
info.RedirectStandardError = true;
info.RedirectStandardInput = true;
info.RedirectStandardOutput = true;
info.UseShellExecute = false;
Process p = Process.Start(info);

p.StandardInput.AutoFlush = true;
p.StandardInput.WriteLine(scriptcode);

p.Kill();

string error = p.StandardError.ReadToEnd();
if (!String.IsNullOrEmpty(error)) 
{
    throw new Exception(error);
}
string output = p.StandardOutput.ReadToEnd();

输出始终为空，即使我从stdout当我手动运行exe时。

Edit：顺便说一句，这是 C# 2.0。

Despite the fact that using GenerateConsoleCtrlEvent() for sending Ctrl+C signal is the right answer, it needs significant clarification to get it to work in different .NET application types.

如果您的 .NET 应用程序不使用自己的控制台（Windows Forms/WPF/Windows Service/ASP.NET），则基本流程是：

1. Attach the main .NET process to the console of the process that you want to signal with Ctrl+C.
2. Prevent the main .NET process from stopping because of Ctrl+C event by disabling handling of the signal with SetConsoleCtrlHandler().
3. 生成控制台事件current控制台与GenerateConsoleCtrlEvent() (processGroupId应该为零！带有发送代码的答案p.SessionId将不起作用并且不正确）。
4. 等待发出信号的进程响应（例如等待它退出）
5. Restore Ctrl+C handling by main process and disconnect from console.

以下代码片段说明了如何执行此操作：

Process p;
if (AttachConsole((uint)p.Id)) {
    SetConsoleCtrlHandler(null, true);
    try { 
        if (!GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0))
            return false;
        p.WaitForExit();
    } finally {
        SetConsoleCtrlHandler(null, false);
        FreeConsole();
    }
    return true;
}

where SetConsoleCtrlHandler(), FreeConsole(), AttachConsole() and GenerateConsoleCtrlEvent()是本机 WinAPI 方法：

internal const int CTRL_C_EVENT = 0;
[DllImport("kernel32.dll")]
internal static extern bool GenerateConsoleCtrlEvent(uint dwCtrlEvent, uint dwProcessGroupId);
[DllImport("kernel32.dll", SetLastError = true)]
internal static extern bool AttachConsole(uint dwProcessId);
[DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
internal static extern bool FreeConsole();
[DllImport("kernel32.dll")]
static extern bool SetConsoleCtrlHandler(ConsoleCtrlDelegate HandlerRoutine, bool Add);
// Delegate type to be used as the Handler Routine for SCCH
delegate Boolean ConsoleCtrlDelegate(uint CtrlType);

Note that waiting for the targeted process to respond, typically by waiting for the process to exit, is critical. Otherwise, the Ctrl+C signal will remain in the current process's input queue and when handling is restored by the second call to SetConsoleCtrlHandler(), that signal will terminate the current process, rather than the targeted one.

Things become more complex if you need to send Ctrl+C from .NET console application. The above approach will not work because AttachConsole() returns false in this case (the main console app already has a console). It is possible to call FreeConsole() before AttachConsole() call, but doing so will result in the original .NET app console being lost, which is not acceptable in most cases.

这是我针对这种情况的解决方案；它可以工作并且对 .NET 主进程控制台没有副作用：

1. Create small supporting .NET console program that accepts process ID from command line arguments, loses its own console with FreeConsole() before the AttachConsole() call and sends Ctrl+C to the target process with code mentioned above.
2. The main .NET console process just invokes this utility in a new process when it needs to send Ctrl+C to another console process.
3. In the main .NET console process call SetConsoleCtrlHandler(null, true) before spawning the "killer"-process (from step 1) and SetConsoleCtrlHandler(null, false) after. Else your main process will also receive Ctrl+C and die