在收到新行之前读取 Process StandardOutput答案

【问题标题】：Read Process StandardOutput before New Line Received在收到新行之前读取 Process StandardOutput
【发布时间】：2014-05-24 08:11:34
【问题描述】：

我正在尝试做一些似乎超出 System.Diagnostics.Process 对象范围的事情。可接受的答案可以提出不同的方法，只要它使用 .net 4.5/c#5。

我的程序正在调用 gdalwarp.exe 以对大型 tiff 文件执行长时间运行的进程。 Galwarp.exe 以这种格式输出。

Creating output file that is 6014P x 4988L.  
Processing input file [FileName].tiff. 
Using band 4 of source image as alpha. 
Using band 4 of destination image as alpha.
0...10...20...30...40...50...60...70...80...90...100 - done.

最后一行缓慢流入以指示进度。我想在它发生变化时阅读该行，以便我可以移动一个进度条让用户了解情况。

首先我尝试读取Process.StandardOutput，但在整个过程完成之前它不会提供任何数据。其次，我尝试调用Process.BeginOutputReadLine() 并连接事件Process.OutputDataReceived，但它仅在一行完成时触发。

这是对 Execute GDalWarp.exe 的调用。

    public static void ResizeTiff(string SourceFile, string DestinationFile, float ResolutionWidth, float ResolutionHeight, Guid ProcessId)
    {
        var directory = GDalBin;
        var exe = Path.Combine(directory, "gdalwarp.exe");
        var args = " -ts " + ResolutionWidth + " " + ResolutionHeight + " -r cubic -co \"TFW=YES\" \"" + SourceFile + "\" \"" + DestinationFile + "\"";
        ExecuteProcess(exe, args, null, directory, 0, null, true, true, 0);
    }

这是我在一个静态函数中的工作代码，它只在进程退出后读取输出。

public static string ExecuteProcess(string FilePath, string Args, string Input, string WorkingDir, int WaitTime = 0, Dictionary<string, string> EnviroVariables = null, bool Trace = false, bool ThrowError = true, int ValidExitCode = 0)
{
    var processInfo =
        "FilePath: " + FilePath + "\n" +
        (WaitTime > 0 ? "WaitTime: " + WaitTime.ToString() + " ms\n" : "") +
        (!string.IsNullOrEmpty(Args) ? "Args: " + Args + "\n" : "") +
        (!string.IsNullOrEmpty(Input) ? "Input: " + Input + "\n" : "") +
        (!string.IsNullOrEmpty(WorkingDir) ? "WorkingDir: " + WorkingDir + "\n" : "") +
        (EnviroVariables != null && EnviroVariables.Count > 0 ? "Environment Variables: " + string.Join(", ", EnviroVariables.Select(a => a.Key + "=" + a.Value)) + "\n" : "");

    if(Trace)
        Log.Debug("Running external process with the following parameters:\n" + processInfo);

    var startInfo = (string.IsNullOrEmpty(Args))
        ? new ProcessStartInfo(FilePath)
        : new ProcessStartInfo(FilePath, Args);

    if (!string.IsNullOrEmpty(WorkingDir))
        startInfo.WorkingDirectory = WorkingDir;

    startInfo.UseShellExecute = false;
    startInfo.RedirectStandardOutput = true;
    startInfo.RedirectStandardError = true;
    startInfo.CreateNoWindow = true;

    if (!string.IsNullOrEmpty(Input))
        startInfo.RedirectStandardInput = true;

    if (EnviroVariables != null)
        foreach (KeyValuePair<String, String> entry in EnviroVariables)
            startInfo.EnvironmentVariables.Add(entry.Key, entry.Value);

    var process = new Process();
    process.StartInfo = startInfo;
    if (process.Start())
    {
        if (Input != null && Input != "")
        {
            process.StandardInput.Write(Input);
            process.StandardInput.Close();
        }
        var standardError = "";
        var standardOutput = "";
        int exitCode = 0;

        var errorReadThread = new Thread(new ThreadStart(() => { standardError = process.StandardError.ReadToEnd(); }));
        var outputReadTread = new Thread(new ThreadStart(() => { standardOutput = process.StandardOutput.ReadToEnd(); }));
        errorReadThread.Start();
        outputReadTread.Start();
        var sw = Stopwatch.StartNew();
        bool timedOut = false;
        try
        {
            while (errorReadThread.IsAlive || outputReadTread.IsAlive)
            {
                Thread.Sleep(50);
                if (WaitTime > 0 && sw.ElapsedMilliseconds > WaitTime)
                {
                    if (errorReadThread.IsAlive) errorReadThread.Abort();
                    if (outputReadTread.IsAlive) outputReadTread.Abort();
                    timedOut = true;
                    break;
                }
            }

            if (!process.HasExited)
                process.Kill();

            if (timedOut)
                throw new TimeoutException("Timeout occurred during execution of an external process.\n" + processInfo + "Standard Output: " + standardOutput + "\nStandard Error: " + standardError);

            exitCode = process.ExitCode;
        }
        finally
        {
            sw.Stop();
            process.Close();
            process.Dispose();
        }

        if (ThrowError && exitCode != ValidExitCode)
            throw new Exception("An error was returned from the execution of an external process.\n" + processInfo + "Exit Code: " + exitCode + "\nStandard Output: " + standardOutput + "\nStandard Error: " + standardError);

        if (Trace)
            Log.Debug("Process Exited with the following values:\nExit Code: {0}\nStandard Output: {1}\nStandard Error: {2}", exitCode, standardOutput, standardError);

        return standardOutput;
    }
    else return null;
}

谁能帮我实时读取这个输出？

【问题讨论】：

你是如何尝试阅读 Stream 的？
我没有发布我当前的方法，因为它们似乎都是死胡同。任何从 System.Diagnostics.Process.StandardOutput.Read() 读取的尝试都会导致调用阻塞，直到进程退出。我将发布我的工作代码，该代码在流程结束时读取一次。
您无法解决此问题，输出在该进程本身中缓冲。每当检测到输出被重定向时，CRT 就会切换到缓冲输出，从而使其速度更快。直到缓冲区填满或关闭输出流（以先到者为准），才会发生输出。需要更改程序以在适当的地方刷新输出，可能在每个点和数字之后。调用 fflush(stdout)。
@HansPassant 当您说“程序”时，您指的是由进程对象 gdalwarp.exe 运行的程序吗？如果是这样，我认为在每个点之后都会刷新输出。当我在命令窗口中运行进程时，点和数字会随着进程的执行而流入。
当然，当 CRT 检测到输出进入控制台时，它不会被缓冲。这当然不会很好。这并不意味着程序本身调用 fflush()，它是自动的。如果你不能改变那个程序，那么责任就到此为止了。

标签： c# system.diagnostics

【解决方案1】：

这是您的问题的解决方案，但有点棘手，因为 gdalwarp.exe 会阻止标准输出，您可以将其输出重定向到文件并读取其上的更改。可以使用 FileSystemWatcher 来检测文件中的更改，但有时它不够可靠。如果 OutputCallback 不为 null，则在下面的 outputReadThread 中使用文件大小更改的简单轮询方法。

这是对 ExecuteProcess 的调用，带有回调以立即接收进程输出。

    public static void ResizeTiff(string SourceFile, string DestinationFile, float ResolutionWidth, float ResolutionHeight, Guid ProcessId)
    {
        var directory = GDalBin;
        var exe = Path.Combine(directory, "gdalwarp.exe");
        var args = " -ts " + ResolutionWidth + " " + ResolutionHeight + " -r cubic -co \"TFW=YES\" \"" + SourceFile + "\" \"" + DestinationFile + "\"";
        float progress = 0;
        Action<string, string> callback = delegate(string fullOutput, string newOutput)
        {
            float value;
            if (float.TryParse(newOutput, out value))
                progress = value;
            else if (newOutput == ".")
                progress += 2.5f;
            else if (newOutput.StartsWith("100"))
                progress = 100;
        };
        ExecuteProcess(exe, args, null, directory, 0, null, true, true, 0, callback);
    }

这是一个调用任何进程并在结果发生时接收结果的函数。

    public static string ExecuteProcess(string FilePath, string Args, string Input, string WorkingDir, int WaitTime = 0, Dictionary<string, string> EnviroVariables = null, bool Trace = false, bool ThrowError = true, int ValidExitCode = 0, Action<string, string> OutputChangedCallback = null)
    {
        var processInfo =
            "FilePath: " + FilePath + "\n" +
            (WaitTime > 0 ? "WaitTime: " + WaitTime.ToString() + " ms\n" : "") +
            (!string.IsNullOrEmpty(Args) ? "Args: " + Args + "\n" : "") +
            (!string.IsNullOrEmpty(Input) ? "Input: " + Input + "\n" : "") +
            (!string.IsNullOrEmpty(WorkingDir) ? "WorkingDir: " + WorkingDir + "\n" : "") +
            (EnviroVariables != null && EnviroVariables.Count > 0 ? "Environment Variables: " + string.Join(", ", EnviroVariables.Select(a => a.Key + "=" + a.Value)) + "\n" : "");

        string outputFile = "";
        if (OutputChangedCallback != null)
        {
            outputFile = Path.GetTempFileName();
            Args = "/C \"\"" + FilePath + "\" " + Args + "\" >" + outputFile;
            FilePath = "cmd.exe";
        }

        var startInfo = (string.IsNullOrEmpty(Args))
            ? new ProcessStartInfo(FilePath)
            : new ProcessStartInfo(FilePath, Args);

        if (!string.IsNullOrEmpty(WorkingDir))
            startInfo.WorkingDirectory = WorkingDir;

        startInfo.UseShellExecute = false;
        startInfo.CreateNoWindow = true;

        if (OutputChangedCallback == null)
        {
            startInfo.RedirectStandardOutput = true;
            startInfo.RedirectStandardError = true;
        }
        else
        {
            startInfo.RedirectStandardOutput = false;
            startInfo.RedirectStandardError = false;
        }

        if (!string.IsNullOrEmpty(Input))
            startInfo.RedirectStandardInput = true;

        if (EnviroVariables != null)
            foreach (KeyValuePair<String, String> entry in EnviroVariables)
                startInfo.EnvironmentVariables.Add(entry.Key, entry.Value);

        var process = new Process();
        process.StartInfo = startInfo;
        if (process.Start())
        {
            if (Trace)
                Log.Debug("Running external process with the following parameters:\n" + processInfo);

            try
            {
                if (!string.IsNullOrEmpty(Input))
                {
                    process.StandardInput.Write(Input);
                    process.StandardInput.Close();
                }
                var standardError = "";
                var standardOutput = "";
                int exitCode = 0;

                Thread errorReadThread;
                Thread outputReadThread;

                if (OutputChangedCallback == null)
                {
                    errorReadThread = new Thread(new ThreadStart(() => { standardError = process.StandardError.ReadToEnd(); }));
                    outputReadThread = new Thread(new ThreadStart(() => { standardOutput = process.StandardOutput.ReadToEnd(); }));
                }
                else
                {
                    errorReadThread = new Thread(new ThreadStart(() => { }));
                    outputReadThread = new Thread(new ThreadStart(() =>
                    {
                        long len = 0;
                        while (!process.HasExited)
                        {
                            if (File.Exists(outputFile))
                            {
                                var info = new FileInfo(outputFile);
                                if (info.Length != len)
                                {
                                    var content = new StreamReader(File.Open(outputFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)).ReadToEnd();
                                    var newContent = content.Substring((int)len, (int)(info.Length - len));
                                    len = info.Length;
                                    OutputChangedCallback.Invoke(content, newContent);
                                }
                            }
                            Thread.Sleep(10);
                        }
                    }));
                }

                errorReadThread.Start();
                outputReadThread.Start();

                var sw = Stopwatch.StartNew();
                bool timedOut = false;
                try
                {
                    while (errorReadThread.IsAlive || outputReadThread.IsAlive)
                    {
                        Thread.Sleep(50);
                        if (WaitTime > 0 && sw.ElapsedMilliseconds > WaitTime)
                        {
                            if (errorReadThread.IsAlive) errorReadThread.Abort();
                            if (outputReadThread.IsAlive) outputReadThread.Abort();
                            timedOut = true;
                            break;
                        }
                    }

                    if (!process.HasExited)
                        process.Kill();

                    if (timedOut)
                        throw new TimeoutException("Timeout occurred during execution of an external process.\n" + processInfo + "Standard Output: " + standardOutput + "\nStandard Error: " + standardError);

                    exitCode = process.ExitCode;
                }
                finally
                {
                    sw.Stop();
                    process.Close();
                    process.Dispose();
                }

                if (ThrowError && exitCode != ValidExitCode)
                    throw new Exception("An error was returned from the execution of an external process.\n" + processInfo + "Exit Code: " + exitCode + "\nStandard Output: " + standardOutput + "\nStandard Error: " + standardError);

                if (Trace)
                    Log.Debug("Process Exited with the following values:\nExit Code: {0}\nStandard Output: {1}\nStandard Error: {2}", exitCode, standardOutput, standardError);

                return standardOutput;
            }
            finally
            {
                FileUtilities.AttemptToDeleteFiles(new string[] { outputFile });
            }
        }
        else
            throw new Exception("The process failed to start.\n" + processInfo);
    }

【讨论】：

这是一个很好的问题模拟。您在 Process1 控制台中收到了什么？最后一行是包含多个事件还是只有一个事件？
进度级别出现在一个事件中，这不是您的解决方案。所以我在轮班结束后编辑了答案:)
这是个好主意，解决了我的问题！非常感谢。
您是否关心我是否使用我使用的最终代码来编辑您的答案？它使用您的概念，但将其集成到我的问题代码中，并使其可供任何有此问题的人重复使用。