我正在通过 exe 执行 BCP 命令，但在复制 50000 行后卡住了。 我查看了一些论坛，了解到如果我们在代码中使用 StandardOuputReader 而不是它的最大输出限制接近 50000 行，这也发生在我身上 有没有一种方法可以让我运行重定向输出，其中可以输出超过 50000 行。

这段代码在我这里有效

proc.StartInfo.RedirectStandardOutput = false;

但我想让它为真，以查看输出。

private static void RunBatch(string Fullfilepath, string BatchFilePathDumpFlatFile)
        {
            mLogger.Error("RunBatch Start=== >");
            mLogger.Error("Batch Filepath " + Fullfilepath + '\n' + "Batch File Directory " + BatchFilePathDumpFlatFile);
            Process proc = null;
            string targetDir = BatchFilePathDumpFlatFile;
            proc = new Process();
            proc.StartInfo.WorkingDirectory = targetDir;
            proc.StartInfo.FileName = Fullfilepath;

            //proc.StartInfo.CreateNoWindow = true;
            proc.StartInfo.UseShellExecute = false;
            proc.StartInfo.Arguments = "/c";
            proc.StartInfo.RedirectStandardError = true;
            proc.StartInfo.RedirectStandardOutput = false;
            proc.Start();
            proc.WaitForExit();
            string output = proc.StandardOutput.ReadToEnd();
            proc.WaitForExit();
            string error = proc.StandardError.ReadToEnd();
            proc.WaitForExit();
            mLogger.Error("Output from batch " + output);
            mLogger.Error("Error From Batch " + error);



        }

更新 1:

private static void RunBatch(string Fullfilepath, string BatchFilePathDumpFlatFile)
        {
            mLogger.Error("RunBatch Start=== >");
            mLogger.Error("Batch Filepath " + Fullfilepath + '\n' + "Batch File Directory " + BatchFilePathDumpFlatFile);
            Process proc = null;
            string targetDir = BatchFilePathDumpFlatFile;
            proc = new Process();
            proc.StartInfo.WorkingDirectory = targetDir;
            proc.StartInfo.FileName = Fullfilepath;

            //proc.StartInfo.CreateNoWindow = true;
            proc.StartInfo.UseShellExecute = false;
            proc.StartInfo.Arguments = "/c";
            proc.StartInfo.RedirectStandardError = true;
            proc.StartInfo.RedirectStandardOutput = true;
            proc.Start();
            string output = proc.StandardOutput.ReadToEnd();
            proc.WaitForExit();
            string error = proc.StandardError.ReadToEnd();
            proc.WaitForExit();
            mLogger.Error("Output from batch " + output);
            mLogger.Error("Error From Batch " + error);



        }

这就是我正在使用的，有没有错误，因为当我停止代码的 exe 时，BCP 仍然挂起并且它开始运行。

最佳答案

这是典型的死锁情况。在完整阅读 StandardOutput 之前，您不应调用 WaitForExit。

当输出被重定向时，进程不会在其所有 StandardOutput 流被读取之前终止。因此调用 WaitForExit 将等待启动的进程终止，子进程将等待父进程在完成之前完全读取输出流，从而发生死锁。

Msdn提供解释和代码示例以避免死锁。

Synchronous read operations introduce a dependency between the caller reading from the StandardOutput stream and the child process writing to that stream. These dependencies can result in deadlock conditions. When the caller reads from the redirected stream of a child process, it is dependent on the child. The caller waits on the read operation until the child writes to the stream or closes the stream. When the child process writes enough data to fill its redirected stream, it is dependent on the parent. The child process waits on the next write operation until the parent reads from the full stream or closes the stream. The deadlock condition results when the caller and child process wait on each other to complete an operation, and neither can proceed. You can avoid deadlocks by evaluating dependencies between the caller and child process.

 // 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();

代码示例通过在 p.WaitForExit 之前调用 p.StandardOutput.ReadToEnd 来避免死锁情况。如果父进程在 p.StandardOutput.ReadToEnd 之前调用 p.WaitForExit 并且子进程写入足够的文本来填充重定向流，则可能会导致死锁情况。父进程将无限期地等待子进程退出。子进程将无限期地等待父进程从完整的 StandardOutput 流中读取。

当您从标准输出流和标准错误流中读取所有文本时，会出现类似的问题。例如，以下 C# 代码对两个流执行读取操作。

 // 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，建议您完整阅读以避免进一步造成死锁。

关于c# - 标准输出阅读器挂起 BCP 工具，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27658977/