C#中Process.StandardOutput.Peek()无法正常工作问题求助

场景复现 #

子进程test程序代码 #

var line = String.Empty;
do
{
    Console.Write($"previous input ==> {line}, type next input> ");
    line = Console.ReadLine();
}
while (!String.IsNullOrWhiteSpace(line) && line != "quit");

Console.WriteLine("End");

父进程启动代码 #

var process = new Process
{
    EnableRaisingEvents = false,
    StartInfo = new ProcessStartInfo
    {
        UseShellExecute = false,
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        RedirectStandardInput = true,
        Arguments = Arguments,
        CreateNoWindow = true,
        FileName = Name,
        WindowStyle = ProcessWindowStyle.Hidden,
        WorkingDirectory = WorkingDirectory
    },
};

process.Start();

String? input;
do
{
    Thread.Sleep(10000); // 等待子进程生成输出

    var line = String.Empty;
    while (process.StandardOutput.Peek() > -1)
        line += (char)process.StandardOutput.Read();
    

    Console.Write($"[Standard Output]{line}\t[New Input]");
    input = Console.ReadLine();
    process.StandardInput.WriteLine(input);
}
while (input != "quit");

实际输出 #

[Standard Output]previous input ==> , type next input>  [New Input]test
[Standard Output]       [New Input]

期望输出 #

[Standard Output]previous input ==> test, type next input>  [New Input]

问题原因 #

1. 子进程输出缓冲未刷新：Console.Write默认采用行缓冲模式，未输出换行符时，内容会留在缓冲区中，不会立即写入标准输出流，导致父进程通过Peek()无法检测到输出。
2. 父进程等待方式不可靠：Thread.Sleep(10000)是固定时长等待，无法精准匹配子进程的输出时机，且同步Peek()的读取方式容易错过缓冲区刷新后的输出。

解决方案 #

步骤1：修改子进程，强制刷新输出缓冲区 #

在Console.Write后添加Console.Out.Flush()，确保输出内容立即写入标准输出流：

var line = String.Empty;
do
{
    Console.Write($"previous input ==> {line}, type next input> ");
    Console.Out.Flush(); // 强制刷新输出缓冲区
    line = Console.ReadLine();
}
while (!String.IsNullOrWhiteSpace(line) && line != "quit");

Console.WriteLine("End");

步骤2：优化父进程的输出读取逻辑 #

改用异步事件监听输出，替代固定时长Sleep和同步Peek，确保及时捕获子进程输出：

var process = new Process
{
    EnableRaisingEvents = true,
    StartInfo = new ProcessStartInfo
    {
        UseShellExecute = false,
        RedirectStandardOutput = true,
        RedirectStandardError = true,
        RedirectStandardInput = true,
        Arguments = Arguments,
        CreateNoWindow = true,
        FileName = Name,
        WindowStyle = ProcessWindowStyle.Hidden,
        WorkingDirectory = WorkingDirectory
    },
};

StringBuilder outputBuffer = new StringBuilder();
// 订阅子进程输出事件
process.OutputDataReceived += (sender, e) =>
{
    if (!string.IsNullOrEmpty(e.Data))
    {
        outputBuffer.Append(e.Data);
    }
};

process.Start();
process.BeginOutputReadLine(); // 启动异步读取输出

String? input;
do
{
    // 等待子进程输出内容
    while (outputBuffer.Length == 0)
    {
        Thread.Sleep(100); // 短轮询避免CPU占用过高
    }

    var output = outputBuffer.ToString();
    outputBuffer.Clear();

    Console.Write($"[Standard Output]{output}\t[New Input]");
    input = Console.ReadLine();
    if (input != null)
    {
        process.StandardInput.WriteLine(input);
        process.StandardInput.Flush(); // 确保输入发送到子进程
    }
}
while (input != "quit");

process.WaitForExit();
process.Dispose();

关键说明 #

• 子进程的Flush()是核心：解决了输出缓冲导致父进程无法读取的问题。
• 异步事件监听比同步轮询更高效：能实时响应子进程的输出，避免固定Sleep带来的延迟或错过输出的问题。

内容的提问来源于stack exchange，提问作者Jerko Sladoljev