StandardOutput.ReadToEnd() 挂起

Question

我有一个经常使用外部程序并读取其输出的程序。 使用通常的进程重定向输出它工作得很好，但是当我尝试读取它时，一个特定的参数由于某种原因挂起，没有错误消息 - 没有例外，它只是在到达该行时“停止”。 我当然使用集中函数来调用和读取程序的输出，即：

public string ADBShell(string adbInput)
{
    try
    {
        //Create Empty values
        string result = string.Empty;
        string error = string.Empty;
        string output = string.Empty;
        System.Diagnostics.ProcessStartInfo procStartInfo 
            = new System.Diagnostics.ProcessStartInfo(toolPath + "adb.exe");

        procStartInfo.Arguments = adbInput;
        procStartInfo.RedirectStandardOutput = true;
        procStartInfo.RedirectStandardError = true;
        procStartInfo.UseShellExecute = false;
        procStartInfo.CreateNoWindow = true;
        procStartInfo.WorkingDirectory = toolPath;
        System.Diagnostics.Process proc = new System.Diagnostics.Process();
        proc.StartInfo = procStartInfo;
        proc.Start();
        // Get the output into a string
        proc.WaitForExit();
        result = proc.StandardOutput.ReadToEnd();
        error = proc.StandardError.ReadToEnd();  //Some ADB outputs use this
        if (result.Length > 1)
        {
            output += result;
        }
        if (error.Length > 1)
        {
            output += error;
        }
        Return output;
    }
    catch (Exception objException)
    {
        throw objException;
    }
}

挂起的行是 result = proc.StandardOutput.ReadToEnd();，但同样，并非每次都是，仅当发送特定参数（“启动服务器”）时。所有其他参数都工作得很好 - 它读取值并返回它。 它悬挂的方式也很奇怪。它不会冻结或给出错误或任何其他内容，它只是停止处理。就像它是一个“返回”命令一样，除了它甚至不返回到调用函数之外，它只是停止一切，而界面仍然启动并运行。 以前有人经历过这个吗？有人知道我应该尝试什么吗？我假设这是流本身中意外的事情，但是有没有办法可以处理/忽略它，以便它无论如何都可以读取它？

Answer 1

建议的使用 BeginOutputReadLine() 的解决方案是一个好方法，但在这种情况下，它不适用，因为进程（当然使用 WaitForExit()）比异步退出更早输出完全完成。

因此，我尝试同步实现它，发现解决方案是使用 StreamReader 类中的 Peek() 方法。我添加了对 Peek() > 的检查-1 以确保它不是流的结尾，如 MSDN 文章 进行了描述，终于可以工作了，不再挂起！

这是代码：

var process = new Process();
process.StartInfo.CreateNoWindow = true;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.WorkingDirectory = @"C:\test\";
process.StartInfo.FileName = "test.exe";
process.StartInfo.Arguments = "your arguments here";

process.Start();
var output = new List<string>();

while (process.StandardOutput.Peek() > -1)
{
    output.Add(process.StandardOutput.ReadLine());
}

while (process.StandardError.Peek() > -1)
{
    output.Add(process.StandardError.ReadLine());
}
process.WaitForExit();

Answer 2

问题是您在 StandardOutput 和 StandardError 流上使用同步 ReadToEnd 方法。这可能会导致您遇到潜在的僵局。 MSDN 中甚至对此进行了描述。那里描述了解决方案。基本上，它是：使用异步版本 BeginOutputReadLine读取StandardOutput流的数据：

p.BeginOutputReadLine();
string error = p.StandardError.ReadToEnd();
p.WaitForExit();

使用BeginOutputReadLine实现异步读取见ProcessStartInfo 挂在“WaitForExit”上？为什么？

Answer 3

怎么样：

process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();

process.OutputDataReceived += (sender, args) =>
{
    var outputData = args.Data;
    // ...
};
process.ErrorDataReceived += (sender, args) =>
{
    var errorData = args.Data;
    // ...
};
process.WaitForExit();

Answer 4

我有同样的死锁问题。这个代码片段对我有用。

ProcessStartInfo startInfo = new ProcessStartInfo("cmd")
{
    WindowStyle = ProcessWindowStyle.Hidden,
    UseShellExecute = false,
    RedirectStandardInput = true,
    RedirectStandardOutput = true,
    CreateNoWindow = true
};

Process process = new Process();
process.StartInfo = startInfo;
process.Start();
process.StandardInput.WriteLine("echo hi");
process.StandardInput.WriteLine("exit");
var output = process.StandardOutput.ReadToEnd();
process.Dispose();

Answer 5

我遇到了同样的问题，错误只是挂起。

根据您对 Daniel Hilgarth 的回复，我什至没有尝试使用这些代码，尽管我认为它们对我有用。

由于我希望能够做出一些更精美的输出，最终我决定在后台线程中完成两个输出。

public static class RunCommands
{
    #region Outputs Property

    private static object _outputsLockObject;
    private static object OutputsLockObject
    { 
        get
        {
            if (_outputsLockObject == null)
                Interlocked.CompareExchange(ref _outputsLockObject, new object(), null);
            return _outputsLockObject;
        }
    }

    private static Dictionary<object, CommandOutput> _outputs;
    private static Dictionary<object, CommandOutput> Outputs
    {
        get
        {
            if (_outputs != null)
                return _outputs;

            lock (OutputsLockObject)
            {
                _outputs = new Dictionary<object, CommandOutput>();
            }
            return _outputs;
        }
    }

    #endregion

    public static string GetCommandOutputSimple(ProcessStartInfo info, bool returnErrorIfPopulated = true)
    {
        // Redirect the output stream of the child process.
        info.UseShellExecute = false;
        info.CreateNoWindow = true;
        info.RedirectStandardOutput = true;
        info.RedirectStandardError = true;
        var process = new Process();
        process.StartInfo = info;
        process.ErrorDataReceived += ErrorDataHandler;
        process.OutputDataReceived += OutputDataHandler;

        var output = new CommandOutput();
        Outputs.Add(process, output);

        process.Start();

        process.BeginErrorReadLine();
        process.BeginOutputReadLine();

        // Wait for the process to finish reading from error and output before it is finished
        process.WaitForExit();

        process.ErrorDataReceived -= ErrorDataHandler;
        process.OutputDataReceived -= OutputDataHandler;

        Outputs.Remove(process);

        if (returnErrorIfPopulated && (!String.IsNullOrWhiteSpace(output.Error)))
        {
            return output.Error.TrimEnd('\n');
        }

        return output.Output.TrimEnd('\n');
    }

    private static void ErrorDataHandler(object sendingProcess, DataReceivedEventArgs errLine)
    {
        if (errLine.Data == null)
            return;

        if (!Outputs.ContainsKey(sendingProcess))
            return;

        var commandOutput = Outputs[sendingProcess];

        commandOutput.Error = commandOutput.Error + errLine.Data + "\n";
    }

    private static void OutputDataHandler(object sendingProcess, DataReceivedEventArgs outputLine)
    {
        if (outputLine.Data == null)
            return;

        if (!Outputs.ContainsKey(sendingProcess))
            return;

        var commandOutput = Outputs[sendingProcess];

        commandOutput.Output = commandOutput.Output + outputLine.Data + "\n";
    }
}
public class CommandOutput
{
    public string Error { get; set; }
    public string Output { get; set; }

    public CommandOutput()
    {
        Error = "";
        Output = "";
    }
}

这对我有用，让我不必在读取时使用超时。

Answer 6

对我来说优雅且有用的东西是：

Process nslookup = new Process()
{
   StartInfo = new ProcessStartInfo("nslookup")
   {
      RedirectStandardInput = true,
      RedirectStandardOutput = true,
      UseShellExecute = false,
      CreateNoWindow = true,
      WindowStyle = ProcessWindowStyle.Hidden
   }
};

nslookup.Start();
nslookup.StandardInput.WriteLine("set type=srv");
nslookup.StandardInput.WriteLine("_ldap._tcp.domain.local"); 

nslookup.StandardInput.Flush();
nslookup.StandardInput.Close();

string output = nslookup.StandardOutput.ReadToEnd();

nslookup.WaitForExit();
nslookup.Close();

我在此处找到了这个答案诀窍是在标准输入上使用 Flush() 和 Close() 。

Answer 7

接受的答案的解决方案对我不起作用。我必须使用任务来避免死锁：

//Code to start process here

String outputResult = GetStreamOutput(process.StandardOutput);
String errorResult = GetStreamOutput(process.StandardError);

process.WaitForExit();

使用 GetStreamOutput 函数，如下所示：

private string GetStreamOutput(StreamReader stream)
{
   //Read output in separate task to avoid deadlocks
   var outputReadTask = Task.Run(() => stream.ReadToEnd());

   return outputReadTask.Result;
}

Answer 8

以防万一有人在想要使用 Windows 窗体和 TextBox（或 RichTextBox）来显示错误并输出过程实时返回的输出时偶然发现这个问题（因为它们是写入 process.StandardOutput / process.StandardError）。

您需要使用 OutputDataReceived() / ErrorDataReceived() 才能在没有死锁的情况下读取两个流，否则无法（据我所知）避免死锁，即使是费多尔的答案，现在拥有“答案”标签并且是最新的最受欢迎的答案，对我来说也不起作用。

然而，当您使用RichTextBox（或TextBox）输出数据时，您遇到的另一个问题是如何将数据实时（一旦到达）实际写入文本框。您可以在后台线程 OutputDataReceived() / ErrorDataReceived() 之一内接收对数据的访问权限，并且您只能从主线程。

我首先尝试做的是从后台线程调用 process.Start() ，然后调用 BeginInvoke() => OutputDataReceived() / ErrorDataReceived() 线程中的 AppendText()，而主线程是 process.WaitForExit()。

然而，这导致我的身体冻结并最终永远悬吊着。经过几天的尝试，我最终得到了下面的解决方案，这似乎工作得很好。

简而言之，您需要将消息添加到 OutputDataReceived() / ErrorDataReceived() 线程内的并发集合中，而主线程应不断尝试从该集合中提取消息，并且将它们附加到文本框中：

            ProcessStartInfo startInfo
                = new ProcessStartInfo(File, mysqldumpCommand);

            process.StartInfo.FileName = File;
            process.StartInfo.Arguments = mysqldumpCommand;
            process.StartInfo.CreateNoWindow = true;
            process.StartInfo.UseShellExecute = false;
            process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
            process.StartInfo.RedirectStandardInput = false;
            process.StartInfo.RedirectStandardError = true;
            process.StartInfo.RedirectStandardOutput = true;
            process.StartInfo.StandardErrorEncoding = Encoding.UTF8;
            process.StartInfo.StandardOutputEncoding = Encoding.UTF8;
            process.EnableRaisingEvents = true;

            ConcurrentQueue<string> messages = new ConcurrentQueue<string>();

            process.ErrorDataReceived += (object se, DataReceivedEventArgs ar) =>
            {
                string data = ar.Data;
                if (!string.IsNullOrWhiteSpace(data))
                    messages.Enqueue(data);
            };
            process.OutputDataReceived += (object se, DataReceivedEventArgs ar) =>
            {
                string data = ar.Data;
                if (!string.IsNullOrWhiteSpace(data))
                    messages.Enqueue(data);
            };

            process.Start();
            process.BeginErrorReadLine();
            process.BeginOutputReadLine();
            while (!process.HasExited)
            {
                string data = null;
                if (messages.TryDequeue(out data))
                    UpdateOutputText(data, tbOutput);
                Thread.Sleep(5);
            }

            process.WaitForExit();

这种方法的唯一缺点是，当进程开始在 process.Start() 和 process 之间写入消息时，您可能会在极少数情况下丢失消息。 BeginErrorReadLine() / process.BeginOutputReadLine()，请记住这一点。避免这种情况的唯一方法是读取完整的流和（或）仅在进程完成时才能访问它们。

Answer 9

第一

     // Start the child process.
     Process p = new Process();
     // Redirect the output stream of the child process.
     p.StartInfo.UseShellExecute = false;
     p.StartInfo.RedirectStandardOutput = true;
     p.StartInfo.FileName = "Write500Lines.exe";
     p.Start();
     // Do not wait for the child process to exit before
     // reading to the end of its redirected stream.
     // p.WaitForExit();
     // Read the output stream first and then wait.
     string output = p.StandardOutput.ReadToEnd();
     p.WaitForExit();

秒

 // Do not perform a synchronous read to the end of both 
 // redirected streams.
 // string output = p.StandardOutput.ReadToEnd();
 // string error = p.StandardError.ReadToEnd();
 // p.WaitForExit();
 // Use asynchronous read operations on at least one of the streams.
 p.BeginOutputReadLine();
 string error = p.StandardError.ReadToEnd();
 p.WaitForExit();

这是来自 MSDN