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

Question

我正在为命令行可执行文件编写一个包装类。该 exe 接受来自 stdin 的输入，直到我在命令提示符 shell 中按下 Ctrl+C，在这种情况下，它会根据以下内容将输出打印到 stdout：输入。我想在 C# 代码中模拟 Ctrl+C 按下，将终止命令发送到 .NET Process 对象。我尝试调用 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();

即使我在手动运行 exe 时从 stdout 获取数据，输出始终为空。

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

Answer 1

尽管事实上使用 GenerateConsoleCtrlEvent() 发送 Ctrl+C 信号是正确的答案，但需要进行大量澄清才能使其正常工作不同的 .NET 应用程序类型。

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

1. 主 .NET 进程附加到要使用 < 发出信号的进程的控制台kbd>Ctrl+C。
2. 通过使用 SetConsoleCtrlHandler() 禁用信号处理，防止主 .NET 进程因 Ctrl+C 事件而停止。
3. 使用 GenerateConsoleCtrlEvent() 为当前控制台生成控制台事件（processGroupId 应为零！答案为发送 p. SessionId 将不起作用并且不正确）。
4. 等待发出信号的进程响应（例如，等待其退出）
5. 恢复主进程的 Ctrl+C 处理并断开与控制台的连接。

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

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

其中 SetConsoleCtrlHandler()、FreeConsole()、AttachConsole() 和 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);

请注意，等待目标进程响应（通常是等待进程退出）至关重要。否则，Ctrl+C 信号将保留在当前进程的输入队列中，并且当通过第二次调用 SetConsoleCtrlHandler() 恢复处理时，该信号将终止当前进程，而不是目标进程。

如果您需要从 .NET 控制台应用程序发送 Ctrl+C，事情会变得更加复杂。上述方法将不起作用，因为在这种情况下 AttachConsole() 返回 false （主控制台应用程序已经有一个控制台）。可以在 AttachConsole() 调用之前调用 FreeConsole()，但这样做会导致原始 .NET 应用控制台丢失，这在大多数情况下是不可接受的。

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

1. 创建小型支持 .NET 控制台程序，该程序从命令行参数接受进程 ID，在 FreeConsole() 之前丢失自己的控制台>AttachConsole() 调用并使用上述代码将 Ctrl+C 发送到目标进程。
2. 当主 .NET 控制台进程需要将 Ctrl+C 发送到另一个控制台进程时，它只会在新进程中调用此实用程序。
3. 在主 .NET 控制台进程中，在生成“杀手”进程（来自步骤 1）之前调用 SetConsoleCtrlHandler(null, true)，并在之后调用 SetConsoleCtrlHandler(null, false)。否则你的主进程也会收到 Ctrl+C 并死亡

Answer 2

其实我刚刚找到了答案。谢谢你们的回答，但事实证明我所要做的就是这样：

p.StandardInput.Close()

这会导致我生成的程序完成从标准输入的读取并输出我需要的内容。

Answer 3

@alonl：用户正在尝试包装命令行程序。命令行程序没有消息泵，除非它们是专门创建的，即使是这样，Ctrl+C 在命令行中也不具有相同的语义。 Windows 环境应用程序（默认情况下复制）就像在命令行环境中一样 (Break)。

我把这个放在一起。 CtrlCClient.exe 只需调用 Console.ReadLine() 并等待：

static void Main(string[] args)
{
    ProcessStartInfo psi = new ProcessStartInfo("CtrlCClient.exe");
    psi.RedirectStandardInput = true;
    psi.RedirectStandardOutput = true;
    psi.RedirectStandardError = true;
    psi.UseShellExecute = false;
    Process proc = Process.Start(psi);
    Console.WriteLine("{0} is active: {1}", proc.Id, !proc.HasExited);
    proc.StandardInput.WriteLine("\x3");
    Console.WriteLine(proc.StandardOutput.ReadToEnd());
    Console.WriteLine("{0} is active: {1}", proc.Id, !proc.HasExited);
    Console.ReadLine();
}

我的输出似乎符合您的要求：

4080 处于活动状态：True
4080 处于活动状态：False

希望有帮助！

（澄清一下：\x3 是十六进制字符 3 的十六进制转义序列，即 Ctrl+C。它不仅仅是一个神奇的数字.;))

Answer 4

好的，这是一个解决方案。

发送Ctrl-C信号的方法是使用GenerateConsoleCtrlEvent。但是，此调用采用 processGroupdID 参数，并将 Ctrl-C 信号发送到组中的所有进程。如果不是因为无法在 .net 中生成与您（父进程）位于不同进程组中的子进程，那就没问题了。因此，当您发送GenerateConsoleCtrlEvent时，子进程都将处于不同的进程组中。您（家长）明白了。因此，您还需要捕获父级中的 Ctrl-C 事件，然后确定是否需要忽略它。

就我而言，我希望父级也能够处理 Ctrl-C 事件，因此我需要区分 Ctrl-C 用户在控制台上发送的事件，以及父进程发送给子进程的事件。我通过在将 Ctrl-C 发送给子级时简单地设置/取消设置布尔标志来做到这一点，然后在父级的 Ctrl< 中检查此标志。 /kbd>-C 事件处理程序（即，如果将 Ctrl-C 发送给子级，则忽略。）

因此，代码看起来像是这样像这样：

//import in the declaration for GenerateConsoleCtrlEvent
[DllImport("kernel32.dll", SetLastError=true)]  
static extern bool GenerateConsoleCtrlEvent(ConsoleCtrlEvent sigevent, int dwProcessGroupId);
public enum ConsoleCtrlEvent  
{  
    CTRL_C = 0,  
    CTRL_BREAK = 1,  
    CTRL_CLOSE = 2,  
    CTRL_LOGOFF = 5,  
    CTRL_SHUTDOWN = 6  
}

//set up the parents CtrlC event handler, so we can ignore the event while sending to the child
public static volatile bool SENDING_CTRL_C_TO_CHILD = false;
static void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
{
    e.Cancel = SENDING_CTRL_C_TO_CHILD;
}

//the main method..
static int Main(string[] args)
{
    //hook up the event handler in the parent
    Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);

    //spawn some child process
    System.Diagnostics.ProcessStartInfo psi = new System.Diagnostics.ProcessStartInfo();
    psi.Arguments = "childProcess.exe";
    Process p = new Process();
    p.StartInfo = psi;
    p.Start();

    //sned the ctrl-c to the process group (the parent will get it too!)
    SENDING_CTRL_C_TO_CHILD = true;
    GenerateConsoleCtrlEvent(ConsoleCtrlEvent.CTRL_C, p.SessionId);        
    p.WaitForExit();
    SENDING_CTRL_C_TO_CHILD = false;

    //note that the ctrl-c event will get called on the parent on background thread
    //so you need to be sure the parent has handled and checked SENDING_CTRL_C_TO_CHILD
    already before setting it to false. 1000 ways to do this, obviously.



    //get out....
    return 0;
}

Answer 5

FWIW，就我而言，我想要的是从控制台进程创建一个子控制台进程（与此相关的 ffmpeg.exe）并支持干净的 CTRL-C 处理在我的进程和子进程中（当按下 CTRL-C 时 ffmpreg 正常退出，这是我想继续工作的一个很好的功能）

我在这里找不到任何解决方案正在工作，所以我只是互操作 Windows' CreateProcess 函数，它无需任何努力即可工作，CTRL-C 由子应用程序和父应用程序自动接收，输入和输出流是共享的，等等。我无法使用标准 .NET Process 类重现此类代码：

    static void RunFFMpeg(string arguments)
    {
        var startup = new STARTUPINFO();
        startup.cb = Marshal.SizeOf<STARTUPINFO>();
        if (!CreateProcess(null, "ffmpeg.exe " + arguments, IntPtr.Zero, IntPtr.Zero, false, 0, IntPtr.Zero, null, ref startup, out var info))
            throw new Win32Exception(Marshal.GetLastWin32Error());

        CloseHandle(info.hProcess);
        CloseHandle(info.hThread);

        var process = Process.GetProcessById(info.dwProcessId);
        Console.CancelKeyPress += (s, e) =>
        {
            process.WaitForExit();
            Console.WriteLine("Abort.");
            // end of program is here
        };

        process.WaitForExit();
        Console.WriteLine("Exit.");
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct PROCESS_INFORMATION
    {
        public IntPtr hProcess;
        public IntPtr hThread;
        public int dwProcessId;
        public int dwThreadId;
    }

    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    private struct STARTUPINFO
    {
        public int cb;
        public string lpReserved;
        public string lpDesktop;
        public string lpTitle;
        public int dwX;
        public int dwY;
        public int dwXSize;
        public int dwYSize;
        public int dwXCountChars;
        public int dwYCountChars;
        public int dwFillAttribute;
        public int dwFlags;
        public short wShowWindow;
        public short cbReserved2;
        public IntPtr lpReserved2;
        public IntPtr hStdInput;
        public IntPtr hStdOutput;
        public IntPtr hStdError;
    }

    [DllImport("kernel32")]
    private static extern bool CloseHandle(IntPtr hObject);

    [DllImport("kernel32", SetLastError = true, CharSet = CharSet.Unicode)]
    private static extern bool CreateProcess(
       string lpApplicationName,
       string lpCommandLine,
       IntPtr lpProcessAttributes,
       IntPtr lpThreadAttributes,
       bool bInheritHandles,
       int dwCreationFlags,
       IntPtr lpEnvironment,
       string lpCurrentDirectory,
       ref STARTUPINFO lpStartupInfo,
       out PROCESS_INFORMATION lpProcessInformation);

Answer 6

尝试实际发送组合键 Ctrl+C，而不是直接终止进程：

 [DllImport("user32.dll")]
        public static extern int SendMessage(
              int hWnd,      // handle to destination window
              uint Msg,       // message
              long wParam,  // first message parameter
              long lParam   // second message parameter
              );

在 MSDN 上查找，您应该在那里找到发送 Ctrl+组合键所需的内容...
我知道您发送 Alt+Key 所需的消息是 WM_SYSTEMKEYDOWN 和 WM_SYSTEMKEYUP，无法告诉您有关 Ctrl 的信息...