在使用控制台应用程序的 C# 中卡在GenerateConsoleCtrlEvent 上

Question

我正经历着最困难的时期，希望你们中有人曾经这样做过。

我有一个 C# 控制台应用程序，它正在运行一个继承其控制台的子进程。 我希望将外部应用程序捕获的 ctrl-c 传递到内部应用程序，以便它有机会很好地关闭。

我有一些非常简单的代码。 我启动一个进程，然后使用 WaitForExit(10) 轮询它。 我还注册了一个 CancelKeyPress 处理程序，它在触发时将 bool 设置为 true。 轮询循环也会检查这一点，当它为真时，它会调用GenerateConsoleCtrlEvent()（我已通过pinvoke映射它）。

我已经尝试了很多GenerateConsoleCtrlEvent() 的参数组合。 第一个参数为 0 或 1，第二个参数为 0 或子进程的 ID。 似乎没什么作用。 有时我会得到错误的返回值，Marshal.GetLastWin32Error() 返回 0，有时我会得到正确的返回值。 但没有一个会导致子应用程序收到 ctrl-c。

为了绝对确定，我编写了一个测试 C# 应用程序作为子应用程序，它会打印出它所发生的情况，并验证在它运行时手动键入 ctrl-c 确实会导致它退出。

我已经为此绞尽脑汁几个小时了。 谁能给我一些关于该去哪里的指示？

Answer 1

不太确定这是一个好方法。 仅当子进程是使用 CreateProcess() 的 CREATE_NEW_PROCESS_GROUP 标志创建时才有效。 然而，System.Diagnostics.Process 类不支持这一点。

考虑使用 Main() 方法的返回值。 Windows SDK 中已为 Ctrl+C 中止定义了一个唯一值：STATUS_CONTROL_C_EXIT 或 0xC000013A。 父进程可以从 Process.ExitCode 属性获取返回代码。

Answer 2

你有这样的运气吗？ 我的理解是，当您在控制台中按 CTRL+C 时，默认情况下连接到控制台的所有进程都会收到它，而不仅仅是父进程。 这是一个示例：

Child.cs:

using System;

public class MyClass
{
    public static void CtrlCHandler(object sender, ConsoleCancelEventArgs args)
    {
        Console.WriteLine("Child killed by CTRL+C.");
    }
    public static void Main()
    {
        Console.WriteLine("Child start.");
        Console.CancelKeyPress += CtrlCHandler;
        System.Threading.Thread.Sleep(4000);
        Console.WriteLine("Child finish.");
    }
}

Parent.cs:

using System;

public class MyClass
{
    public static void CtrlCHandler(object sender, ConsoleCancelEventArgs args)
    {
        Console.WriteLine("Parent killed by CTRL+C.");
    }
    public static void Main()
    {
        Console.CancelKeyPress += CtrlCHandler;
        Console.WriteLine("Parent start.");
        System.Diagnostics.Process child = new System.Diagnostics.Process();
        child.StartInfo.UseShellExecute = false;
        child.StartInfo.FileName = "child.exe";
        child.Start();
        child.WaitForExit();
        Console.WriteLine("Parent finish.");
    }
}

Output:

Y:\>parent
Parent start.
Child start.
Parent killed by CTRL+C.
Child killed by CTRL+C.
^C
Y:\>parent
Parent start.
Child start.
Child finish.
Parent finish.

所以我不认为您需要做任何特别的事情。 但是，如果您确实需要自己生成 CTRL+C 事件，事情可能就不那么容易了。 我不确定您描述的问题，但据我所知，您只能将 CTRL+C 事件发送到附加到控制台窗口的所有进程。 如果分离进程，则无法向其发送 CTRL+C 事件。 如果您想选择在哪些进程中发送 CTRL+C 事件，则似乎需要为每个进程创建新的控制台窗口。 我不知道是否有某种方法可以在没有可见窗口的情况下执行此操作，或者当您想使用管道重定向 I/O 时。

Answer 3

这是我将 ctrl-c 发送到进程的解决方案。 仅供参考，我从来没有让 GenerateConsoleCtrlEvent 工作。

下面是我发现的将 CTRL-C 发送到进程的方法，而不是使用GenerateConsoleCtrlEvent。 仅供参考，在这种情况下，我不需要查找组进程 ID。

using System;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

public class ConsoleAppManager
{
    private readonly string appName;
    private readonly Process process = new Process();
    private readonly object theLock = new object();
    private SynchronizationContext context;
    private string pendingWriteData;

    public ConsoleAppManager(string appName)
    {
        this.appName = appName;

        this.process.StartInfo.FileName = this.appName;
        this.process.StartInfo.RedirectStandardError = true;
        this.process.StartInfo.StandardErrorEncoding = Encoding.UTF8;

        this.process.StartInfo.RedirectStandardInput = true;
        this.process.StartInfo.RedirectStandardOutput = true;
        this.process.EnableRaisingEvents = true;
        this.process.StartInfo.CreateNoWindow = true;

        this.process.StartInfo.UseShellExecute = false;

        this.process.StartInfo.StandardOutputEncoding = Encoding.UTF8;

        this.process.Exited += this.ProcessOnExited;
    }

    public event EventHandler<string> ErrorTextReceived;
    public event EventHandler ProcessExited;
    public event EventHandler<string> StandartTextReceived;

    public int ExitCode
    {
        get { return this.process.ExitCode; }
    }

    public bool Running
    {
        get; private set;
    }

    public void ExecuteAsync(params string[] args)
    {
        if (this.Running)
        {
            throw new InvalidOperationException(
                "Process is still Running. Please wait for the process to complete.");
        }

        string arguments = string.Join(" ", args);

        this.process.StartInfo.Arguments = arguments;

        this.context = SynchronizationContext.Current;

        this.process.Start();
        this.Running = true;

        new Task(this.ReadOutputAsync).Start();
        new Task(this.WriteInputTask).Start();
        new Task(this.ReadOutputErrorAsync).Start();
    }

    public void Write(string data)
    {
        if (data == null)
        {
            return;
        }

        lock (this.theLock)
        {
            this.pendingWriteData = data;
        }
    }

    public void WriteLine(string data)
    {
        this.Write(data + Environment.NewLine);
    }

    protected virtual void OnErrorTextReceived(string e)
    {
        EventHandler<string> handler = this.ErrorTextReceived;

        if (handler != null)
        {
            if (this.context != null)
            {
                this.context.Post(delegate { handler(this, e); }, null);
            }
            else
            {
                handler(this, e);
            }
        }
    }

    protected virtual void OnProcessExited()
    {
        EventHandler handler = this.ProcessExited;
        if (handler != null)
        {
            handler(this, EventArgs.Empty);
        }
    }

    protected virtual void OnStandartTextReceived(string e)
    {
        EventHandler<string> handler = this.StandartTextReceived;

        if (handler != null)
        {
            if (this.context != null)
            {
                this.context.Post(delegate { handler(this, e); }, null);
            }
            else
            {
                handler(this, e);
            }
        }
    }

    private void ProcessOnExited(object sender, EventArgs eventArgs)
    {
        this.OnProcessExited();
    }

    private async void ReadOutputAsync()
    {
        var standart = new StringBuilder();
        var buff = new char[1024];
        int length;

        while (this.process.HasExited == false)
        {
            standart.Clear();

            length = await this.process.StandardOutput.ReadAsync(buff, 0, buff.Length);
            standart.Append(buff.SubArray(0, length));
            this.OnStandartTextReceived(standart.ToString());
            Thread.Sleep(1);
        }

        this.Running = false;
    }

    private async void ReadOutputErrorAsync()
    {
        var sb = new StringBuilder();

        do
        {
            sb.Clear();
            var buff = new char[1024];
            int length = await this.process.StandardError.ReadAsync(buff, 0, buff.Length);
            sb.Append(buff.SubArray(0, length));
            this.OnErrorTextReceived(sb.ToString());
            Thread.Sleep(1);
        }
        while (this.process.HasExited == false);
    }

    private async void WriteInputTask()
    {
        while (this.process.HasExited == false)
        {
            Thread.Sleep(1);

            if (this.pendingWriteData != null)
            {
                await this.process.StandardInput.WriteLineAsync(this.pendingWriteData);
                await this.process.StandardInput.FlushAsync();

                lock (this.theLock)
                {
                    this.pendingWriteData = null;
                }
            }
        }
    }
}

然后，在实际运行该进程并在我的主应用程序中发送 CTRL-C 时：

            DateTime maxStartDateTime = //... some date time;
            DateTime maxEndDateTime = //... some later date time
            var duration = maxEndDateTime.Subtract(maxStartDateTime);
            ConsoleAppManager appManager = new ConsoleAppManager("myapp.exe");
            string[] args = new string[] { "args here" };
            appManager.ExecuteAsync(args);
            await Task.Delay(Convert.ToInt32(duration.TotalSeconds * 1000) + 20000);

            if (appManager.Running)
            {
                // If stilll running, send CTRL-C
                appManager.Write("\x3");
            }

有关详细信息，请参阅 重定向控制台应用程序的标准输入和Windows如何获取已经运行的进程的进程组？