Question

我需要为交互式命令行程序编写一个包装器。

这意味着我需要能够通过其标准输入向其他程序发送命令，并通过其标准输出接收响应。

问题是，当输入流仍处于打开状态时，标准输出流似乎被阻止。一旦我关闭输入流，我就得到响应。但后来我无法发送更多命令。

这就是我目前使用的内容（主要来自here）：

void Main() {
    Process process;
    process = new Process();
    process.StartInfo.FileName = "atprogram.exe";
    process.StartInfo.Arguments = "interactive";

    // Set UseShellExecute to false for redirection.
    process.StartInfo.UseShellExecute = false;
    process.StartInfo.CreateNoWindow = true;

    // Redirect the standard output of the command.  
    // This stream is read asynchronously using an event handler.
    process.StartInfo.RedirectStandardOutput = true;
    // Set our event handler to asynchronously read the output.
    process.OutputDataReceived += (s, e) => Console.WriteLine(e.Data);

    // Redirect standard input as well. This stream is used synchronously.
    process.StartInfo.RedirectStandardInput = true;
    process.Start();

    // Start the asynchronous read of the output stream.
    process.BeginOutputReadLine();

    String inputText;
    do 
    {
        inputText = Console.ReadLine();
        if (inputText == "q")
        {
            process.StandardInput.Close();   // After this line the output stream unblocks
            Console.ReadLine();
            return;
        }
        else if (!String.IsNullOrEmpty(inputText))
        {
            process.StandardInput.WriteLine(inputText);
        }
    }
}

我也试过同步读取标准输出流，但结果相同。输出流上的任何方法调用都会无限期地阻塞，直到输入流关闭 - 甚至是Peek()和EndOfStream。

有没有办法以全双工的方式与其他进程通信？

Answer 1

我尝试使用自己的小型测试套件重现您的问题。我没有使用事件处理程序，而是以我能想到的最简单的方式来实现：同步。这样就不会给问题增加额外的复杂性。

这里是我的小＆＃34; echoApp＆＃34;我写的是铁锈，只是为了咯咯笑，还有机会遇到永恒的终止战争问题（\n vs \r vs \r\n）。根据命令行应用程序的编写方式，这可能确实是您的问题之一。

use std::io;

fn main() {
    let mut counter = 0;
    loop {
        let mut input = String::new();
        let _ = io::stdin().read_line(&mut input);
        match &input.trim() as &str {
            "quit" => break,
            _ => {
                println!("{}: {}", counter, input);
                counter += 1;
            }
        }
    }
}

而且 - 作为一个不喜欢为这么小的测试创建解决方案的懒骨头，我使用F＃代替C＃作为控制方 - 我觉得这很容易阅读：

open System.Diagnostics;

let echoPath = @"E:\R\rustic\echo\echoApp\target\debug\echoApp.exe"

let createControlledProcess path = 
    let p = new Process()
    p.StartInfo.UseShellExecute <- false
    p.StartInfo.RedirectStandardInput <- true
    p.StartInfo.RedirectStandardOutput <- true
    p.StartInfo.Arguments <- ""
    p.StartInfo.FileName <- path
    p.StartInfo.CreateNoWindow <- true
    p

let startupControlledProcess (p : Process) =
    if p.Start() 
    then 
        p.StandardInput.NewLine <- "\r\n"
    else ()

let shutdownControlledProcess (p : Process) =
    p.StandardInput.WriteLine("quit");
    p.WaitForExit()
    p.Close()

let interact (p : Process) (arg : string) : string =
    p.StandardInput.WriteLine(arg);
    let o = p.StandardOutput.ReadLine()
    // we get funny empty lines every other time... 
    // probably some line termination problem ( unix \n vs \r\n etc - 
    // who can tell what rust std::io does...?)
    if o = "" then p.StandardOutput.ReadLine()
    else o

let p = createControlledProcess echoPath
startupControlledProcess p
let results = 
    [
        interact p "Hello"
        interact p "World"
        interact p "Whatever"
        interact p "floats"
        interact p "your"
        interact p "boat"
    ]
shutdownControlledProcess p

在f＃interactive（CTRL-A ALT-Enter in Visual Studio）中执行此操作会产生：

val echoPath：string =＆＃34; E：\ R \ rustic \ echo \ echoApp \ target \ debug \ echoApp.exe＆＃34;

val createControlledProcess：path：string - ＆gt;过程

val startupControlledProcess：p：Process - ＆gt;单位

val shutdownControlledProcess：p：Process - ＆gt;单位

val interaction：p：Process - ＆gt; arg：string - ＆gt;字符串

val p：Process = System.Diagnostics.Process

val results：string list =

[＆＃34; 0：你好＆＃34 ;; ＆＃34; 1：世界＆＃34 ;; ＆＃34; 2：无论如何＆＃34 ;; ＆＃34; 3：花车＆＃34 ;; ＆＃34; 4：你的＆＃34 ;; ＆＃34; 5：船＆＃34;]

val it：unit =（）

我无法重现任何阻塞或死锁等。因此，在您的情况下，我会尝试调查您的NewLine属性是否需要进行一些调整（请参阅函数startupControlledProcess。如果受控应用程序无法将输入识别为行，则可能无法响应，仍然等待输入线的其余部分，你可能会得到你的效果。

Answer 2

process.BeginOutputReadLine();

不能按预期工作，因为它一直等到输出流将被关闭为止，这将在进程结束时发生，而进程将在其输入流关闭时结束。解决方法只是使用process.StandardOutput.ReadLine()和您自己创建的异步

的组合

如何使用来自另一个.NET程序的交互式命令行程序

2 个答案: