blocks|key|1740027|text|Process.StandardOutput的documentation告诉你在等待之前先读，否则你会死锁，下面是复制的代码片段：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1740028|+//+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();|code-block|syntax|javascript|1740029|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.diagnostics.process.standardoutput.aspx^0|0|M|N|D|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

The <a href="http://msdn.microsoft.com/en-us/library/system.diagnostics.process.standardoutput.aspx" rel="noreferrer">documentation</a> for <code>Process.StandardOutput</code> says to read before you wait otherwise you can deadlock, snippet copied below:

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

blocks|key|1525026|text|这篇文章可能已经过时了，但我发现它通常挂起的主要原因是redirectStandardoutput的堆栈溢出，或者如果你有redirectStandarderror。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1525027|由于输出数据或错误数据较大，由于仍在处理不确定的时间，因此会导致挂起时间。|1525028|所以要解决这个问题：|1525029|p.StartInfo.RedirectStandardoutput+=+False
p.StartInfo.RedirectStandarderror+=+False|code-block|syntax|javascript|1525030|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This post maybe outdated but i found out the main cause why it usually hang is due to stack overflow for the redirectStandardoutput or if you have redirectStandarderror.

As the output data or the error data is large, it will cause a hang time as it is still processing for indefinite duration.

so to resolve this issue:

<pre><code>p.StartInfo.RedirectStandardoutput = False
p.StartInfo.RedirectStandarderror = False
</code></pre>

blocks|key|1740131|text|马克·拜尔斯的回答很好，但我只想补充一下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1740132|在处理outputWaitHandle和errorWaitHandle之前，需要移除OutputDataReceived和ErrorDataReceived委托。如果进程在超时后继续输出数据，然后终止，则outputWaitHandle和errorWaitHandle变量将在释放后被访问。|offset|length|style|CODE|1740133|(仅供参考，我不得不添加此警告作为答案，因为我无法对他的帖子发表评论。)|1740134|entityMap^0|0|3|G|K|F|16|I|1P|H|2U|G|3B|F|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]|$D|R|E|S|F|G]|$D|T|E|U|F|G]|$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|K|$]]

Mark Byers' answer is excellent, but I would just add the following: 

The <code>OutputDataReceived</code> and <code>ErrorDataReceived</code> delegates need to be removed before the <code>outputWaitHandle</code> and <code>errorWaitHandle</code> get disposed. If the process continues to output data after the timeout has been exceeded and then terminates, the <code>outputWaitHandle</code> and <code>errorWaitHandle</code> variables will be accessed after being disposed.

(FYI I had to add this caveat as an answer as I couldn't comment on his post.)

blocks|key|1525153|text|我认为这是一种简单且更好的方法(我们不需要AutoResetEvent)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1525154|public+static+string+GGSCIShell(string+Path,+string+Command)
{
++++using+(Process+process+=+new+Process())
++++{
++++++++process.StartInfo.WorkingDirectory+=+Path;
++++++++process.StartInfo.FileName+=+Path+%2B+@"\ggsci.exe";
++++++++process.StartInfo.CreateNoWindow+=+true;
++++++++process.StartInfo.RedirectStandardOutput+=+true;
++++++++process.StartInfo.RedirectStandardInput+=+true;
++++++++process.StartInfo.UseShellExecute+=+false;

++++++++StringBuilder+output+=+new+StringBuilder();
++++++++process.OutputDataReceived+%2B=+(sender,+e)+=>
++++++++{
++++++++++++if+(e.Data+!=+null)
++++++++++++{
++++++++++++++++output.AppendLine(e.Data);
++++++++++++}
++++++++};

++++++++process.Start();
++++++++process.StandardInput.WriteLine(Command);
++++++++process.BeginOutputReadLine();


++++++++int+timeoutParts+=+10;
++++++++int+timeoutPart+=+(int)TIMEOUT+/+timeoutParts;
++++++++do
++++++++{
++++++++++++Thread.Sleep(500);//sometimes+halv+scond+is+enough+to+empty+output+buff+(therefore+"exit"+will+be+accepted+without+"timeoutPart"+waiting)
++++++++++++process.StandardInput.WriteLine("exit");
++++++++++++timeoutParts--;
++++++++}
++++++++while+(!process.WaitForExit(timeoutPart)+&&+timeoutParts+>+0);

++++++++if+(timeoutParts+<=+0)
++++++++{
++++++++++++output.AppendLine("------+GGSCIShell+TIMEOUT:+"+%2B+TIMEOUT+%2B+"ms+------");
++++++++}

++++++++string+result+=+output.ToString();
++++++++return+result;
++++}
}|code-block|syntax|javascript|1525155|entityMap^0|L|E|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I thing that this is simple and better approach (we don't need <code>AutoResetEvent</code>):

<pre><code>public static string GGSCIShell(string Path, string Command)
{
 using (Process process = new Process())
 {
 process.StartInfo.WorkingDirectory = Path;
 process.StartInfo.FileName = Path + @"\ggsci.exe";
 process.StartInfo.CreateNoWindow = true;
 process.StartInfo.RedirectStandardOutput = true;
 process.StartInfo.RedirectStandardInput = true;
 process.StartInfo.UseShellExecute = false;

 StringBuilder output = new StringBuilder();
 process.OutputDataReceived += (sender, e) =&gt;
 {
 if (e.Data != null)
 {
 output.AppendLine(e.Data);
 }
 };

 process.Start();
 process.StandardInput.WriteLine(Command);
 process.BeginOutputReadLine();


 int timeoutParts = 10;
 int timeoutPart = (int)TIMEOUT / timeoutParts;
 do
 {
 Thread.Sleep(500);//sometimes halv scond is enough to empty output buff (therefore "exit" will be accepted without "timeoutPart" waiting)
 process.StandardInput.WriteLine("exit");
 timeoutParts--;
 }
 while (!process.WaitForExit(timeoutPart) &amp;&amp; timeoutParts &gt; 0);

 if (timeoutParts &lt;= 0)
 {
 output.AppendLine("------ GGSCIShell TIMEOUT: " + TIMEOUT + "ms ------");
 }

 string result = output.ToString();
 return result;
 }
}
</code></pre>

blocks|key|1740253|text|未处理的ObjectDisposedException的问题发生在进程超时时。在这种情况下，条件的其他部分：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1740254|if+(process.WaitForExit(timeout)+
++++&&+outputWaitHandle.WaitOne(timeout)+
++++&&+errorWaitHandle.WaitOne(timeout))|code-block|syntax|javascript|1740255|不会被执行。我通过以下方式解决了这个问题：|1740256|using+(AutoResetEvent+outputWaitHandle+=+new+AutoResetEvent(false))
using+(AutoResetEvent+errorWaitHandle+=+new+AutoResetEvent(false))
{
++++using+(Process+process+=+new+Process())
++++{
++++++++//+preparing+ProcessStartInfo

++++++++try
++++++++{
++++++++++++process.OutputDataReceived+%2B=+(sender,+e)+=>
++++++++++++++++{
++++++++++++++++++++if+(e.Data+==+null)
++++++++++++++++++++{
++++++++++++++++++++++++outputWaitHandle.Set();
++++++++++++++++++++}
++++++++++++++++++++else
++++++++++++++++++++{
++++++++++++++++++++++++outputBuilder.AppendLine(e.Data);
++++++++++++++++++++}
++++++++++++++++};
++++++++++++process.ErrorDataReceived+%2B=+(sender,+e)+=>
++++++++++++++++{
++++++++++++++++++++if+(e.Data+==+null)
++++++++++++++++++++{
++++++++++++++++++++++++errorWaitHandle.Set();
++++++++++++++++++++}
++++++++++++++++++++else
++++++++++++++++++++{
++++++++++++++++++++++++errorBuilder.AppendLine(e.Data);
++++++++++++++++++++}
++++++++++++++++};

++++++++++++process.Start();

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

++++++++++++if+(process.WaitForExit(timeout))
++++++++++++{
++++++++++++++++exitCode+=+process.ExitCode;
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++//+timed+out
++++++++++++}

++++++++++++output+=+outputBuilder.ToString();
++++++++}
++++++++finally
++++++++{
++++++++++++outputWaitHandle.WaitOne(timeout);
++++++++++++errorWaitHandle.WaitOne(timeout);
++++++++}
++++}
}|1740257|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The problem with unhandled ObjectDisposedException happens when the process is timed out. In such case the other parts of the condition:

<pre><code>if (process.WaitForExit(timeout) 
 &amp;&amp; outputWaitHandle.WaitOne(timeout) 
 &amp;&amp; errorWaitHandle.WaitOne(timeout))
</code></pre>

are not executed. I resolved this problem in a following way:

<pre><code>using (AutoResetEvent outputWaitHandle = new AutoResetEvent(false))
using (AutoResetEvent errorWaitHandle = new AutoResetEvent(false))
{
 using (Process process = new Process())
 {
 // preparing ProcessStartInfo

 try
 {
 process.OutputDataReceived += (sender, e) =&gt;
 {
 if (e.Data == null)
 {
 outputWaitHandle.Set();
 }
 else
 {
 outputBuilder.AppendLine(e.Data);
 }
 };
 process.ErrorDataReceived += (sender, e) =&gt;
 {
 if (e.Data == null)
 {
 errorWaitHandle.Set();
 }
 else
 {
 errorBuilder.AppendLine(e.Data);
 }
 };

 process.Start();

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

 if (process.WaitForExit(timeout))
 {
 exitCode = process.ExitCode;
 }
 else
 {
 // timed out
 }

 output = outputBuilder.ToString();
 }
 finally
 {
 outputWaitHandle.WaitOne(timeout);
 errorWaitHandle.WaitOne(timeout);
 }
 }
}
</code></pre>

blocks|key|1740331|text|我也有同样的问题，但原因不同。然而，它会在Windows+8下发生，但不会在Windows+7下发生。下面这行似乎导致了问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1740332|pProcess.StartInfo.UseShellExecute+=+False|code-block|syntax|javascript|1740333|解决方案是不禁用UseShellExecute。我现在收到了一个Shell弹出窗口，这不是我想要的，但比程序等待没有什么特别的事情发生要好得多。因此，我为此添加了以下解决方法：|1740334|pProcess.StartInfo.WindowStyle+=+ProcessWindowStyle.Hidden|1740335|现在唯一困扰我的是为什么这会发生在Windows8下。|1740336|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I was having the same issue, but the reason was different. It would however happen under Windows 8, but not under Windows 7. The following line seems to have caused the problem.

<pre><code>pProcess.StartInfo.UseShellExecute = False
</code></pre>

The solution was to NOT disable UseShellExecute. I now received a Shell popup window, which is unwanted, but much better than the program waiting for nothing particular to happen. So I added the following work-around for that:

<pre><code>pProcess.StartInfo.WindowStyle = ProcessWindowStyle.Hidden
</code></pre>

Now the only thing bothering me is to why this is happening under Windows 8 in the first place.

blocks|key|1525402|text|我是这样解决的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1525403|++++++++++++Process+proc+=+new+Process();
++++++++++++proc.StartInfo.FileName+=+batchFile;
++++++++++++proc.StartInfo.UseShellExecute+=+false;
++++++++++++proc.StartInfo.CreateNoWindow+=+true;
++++++++++++proc.StartInfo.RedirectStandardError+=+true;
++++++++++++proc.StartInfo.RedirectStandardInput+=+true;
++++++++++++proc.StartInfo.RedirectStandardOutput+=+true;
++++++++++++proc.StartInfo.WindowStyle+=+ProcessWindowStyle.Hidden;++++++
++++++++++++proc.Start();
++++++++++++StreamWriter+streamWriter+=+proc.StandardInput;
++++++++++++StreamReader+outputReader+=+proc.StandardOutput;
++++++++++++StreamReader+errorReader+=+proc.StandardError;
++++++++++++while+(!outputReader.EndOfStream)
++++++++++++{
++++++++++++++++string+text+=+outputReader.ReadLine();++++++++++++++++++++
++++++++++++++++streamWriter.WriteLine(text);
++++++++++++}

++++++++++++while+(!errorReader.EndOfStream)
++++++++++++{+++++++++++++++++++
++++++++++++++++string+text+=+errorReader.ReadLine();
++++++++++++++++streamWriter.WriteLine(text);
++++++++++++}

++++++++++++streamWriter.Close();
++++++++++++proc.WaitForExit();|code-block|syntax|javascript|1525404|我重定向了输入、输出和错误，并处理了输出和错误流的读取。此解决方案适用于SDK+7-+8.1，适用于Windows+7和Windows+8|1525405|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I solved it this way:

<pre><code> Process proc = new Process();
 proc.StartInfo.FileName = batchFile;
 proc.StartInfo.UseShellExecute = false;
 proc.StartInfo.CreateNoWindow = true;
 proc.StartInfo.RedirectStandardError = true;
 proc.StartInfo.RedirectStandardInput = true;
 proc.StartInfo.RedirectStandardOutput = true;
 proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden; 
 proc.Start();
 StreamWriter streamWriter = proc.StandardInput;
 StreamReader outputReader = proc.StandardOutput;
 StreamReader errorReader = proc.StandardError;
 while (!outputReader.EndOfStream)
 {
 string text = outputReader.ReadLine(); 
 streamWriter.WriteLine(text);
 }

 while (!errorReader.EndOfStream)
 { 
 string text = errorReader.ReadLine();
 streamWriter.WriteLine(text);
 }

 streamWriter.Close();
 proc.WaitForExit();
</code></pre>

I redirected both input, output and error and handled reading from output and error streams.
This solution works for SDK 7- 8.1, both for Windows 7 and Windows 8

blocks|key|1740512|text|Rob回答了这个问题，为我节省了几个小时的试用期。在等待之前读取输出/错误缓冲区：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1740513|//+Read+the+output+stream+first+and+then+wait.
string+output+=+p.StandardOutput.ReadToEnd();
p.WaitForExit();|code-block|syntax|javascript|1740514|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Rob answered it and saved me few more hours of trials. Read the output/error buffer before waiting:

<pre><code>// Read the output stream first and then wait.
string output = p.StandardOutput.ReadToEnd();
p.WaitForExit();
</code></pre>

blocks|key|1740612|text|这是一个更现代的、可等待的、基于任务并行库的解决方案，适用于.NET+4.5及更高版本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1740613|使用示例|1740614|try
{
++++var+exitCode+=+await+StartProcess(
++++++++"dotnet",+
++++++++"--version",+
++++++++@"C:\",
++++++++10000,+
++++++++Console.Out,+
++++++++Console.Out);
++++Console.WriteLine($"Process+Exited+with+Exit+Code+{exitCode}!");
}
catch+(TaskCanceledException)
{
++++Console.WriteLine("Process+Timed+Out!");
}|code-block|syntax|javascript|1740615|实现|1740616|public+static+async+Task<int>+StartProcess(
++++string+filename,
++++string+arguments,
++++string+workingDirectory=+null,
++++int?+timeout+=+null,
++++TextWriter+outputTextWriter+=+null,
++++TextWriter+errorTextWriter+=+null)
{
++++using+(var+process+=+new+Process()
++++{
++++++++StartInfo+=+new+ProcessStartInfo()
++++++++{
++++++++++++CreateNoWindow+=+true,
++++++++++++Arguments+=+arguments,
++++++++++++FileName+=+filename,
++++++++++++RedirectStandardOutput+=+outputTextWriter+!=+null,
++++++++++++RedirectStandardError+=+errorTextWriter+!=+null,
++++++++++++UseShellExecute+=+false,
++++++++++++WorkingDirectory+=+workingDirectory
++++++++}
++++})
++++{
++++++++var+cancellationTokenSource+=+timeout.HasValue+?
++++++++++++new+CancellationTokenSource(timeout.Value)+:
++++++++++++new+CancellationTokenSource();

++++++++process.Start();

++++++++var+tasks+=+new+List<Task>(3)+{+process.WaitForExitAsync(cancellationTokenSource.Token)+};
++++++++if+(outputTextWriter+!=+null)
++++++++{
++++++++++++tasks.Add(ReadAsync(
++++++++++++++++x+=>
++++++++++++++++{
++++++++++++++++++++process.OutputDataReceived+%2B=+x;
++++++++++++++++++++process.BeginOutputReadLine();
++++++++++++++++},
++++++++++++++++x+=>+process.OutputDataReceived+-=+x,
++++++++++++++++outputTextWriter,
++++++++++++++++cancellationTokenSource.Token));
++++++++}

++++++++if+(errorTextWriter+!=+null)
++++++++{
++++++++++++tasks.Add(ReadAsync(
++++++++++++++++x+=>
++++++++++++++++{
++++++++++++++++++++process.ErrorDataReceived+%2B=+x;
++++++++++++++++++++process.BeginErrorReadLine();
++++++++++++++++},
++++++++++++++++x+=>+process.ErrorDataReceived+-=+x,
++++++++++++++++errorTextWriter,
++++++++++++++++cancellationTokenSource.Token));
++++++++}

++++++++await+Task.WhenAll(tasks);
++++++++return+process.ExitCode;
++++}
}

///+<summary>
///+Waits+asynchronously+for+the+process+to+exit.
///+</summary>
///+<param+name="process">The+process+to+wait+for+cancellation.</param>
///+<param+name="cancellationToken">A+cancellation+token.+If+invoked,+the+task+will+return
///+immediately+as+cancelled.</param>
///+<returns>A+Task+representing+waiting+for+the+process+to+end.</returns>
public+static+Task+WaitForExitAsync(
++++this+Process+process,
++++CancellationToken+cancellationToken+=+default(CancellationToken))
{
++++process.EnableRaisingEvents+=+true;

++++var+taskCompletionSource+=+new+TaskCompletionSource<object>();

++++EventHandler+handler+=+null;
++++handler+=+(sender,+args)+=>
++++{
++++++++process.Exited+-=+handler;
++++++++taskCompletionSource.TrySetResult(null);
++++};
++++process.Exited+%2B=+handler;

++++if+(cancellationToken+!=+default(CancellationToken))
++++{
++++++++cancellationToken.Register(
++++++++++++()+=>
++++++++++++{
++++++++++++++++process.Exited+-=+handler;
++++++++++++++++taskCompletionSource.TrySetCanceled();
++++++++++++});
++++}

++++return+taskCompletionSource.Task;
}

///+<summary>
///+Reads+the+data+from+the+specified+data+recieved+event+and+writes+it+to+the
///+<paramref+name="textWriter"/>.
///+</summary>
///+<param+name="addHandler">Adds+the+event+handler.</param>
///+<param+name="removeHandler">Removes+the+event+handler.</param>
///+<param+name="textWriter">The+text+writer.</param>
///+<param+name="cancellationToken">The+cancellation+token.</param>
///+<returns>A+task+representing+the+asynchronous+operation.</returns>
public+static+Task+ReadAsync(
++++this+Action<DataReceivedEventHandler>+addHandler,
++++Action<DataReceivedEventHandler>+removeHandler,
++++TextWriter+textWriter,
++++CancellationToken+cancellationToken+=+default(CancellationToken))
{
++++var+taskCompletionSource+=+new+TaskCompletionSource<object>();

++++DataReceivedEventHandler+handler+=+null;
++++handler+=+new+DataReceivedEventHandler(
++++++++(sender,+e)+=>
++++++++{
++++++++++++if+(e.Data+==+null)
++++++++++++{
++++++++++++++++removeHandler(handler);
++++++++++++++++taskCompletionSource.TrySetResult(null);
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++textWriter.WriteLine(e.Data);
++++++++++++}
++++++++});

++++addHandler(handler);

++++if+(cancellationToken+!=+default(CancellationToken))
++++{
++++++++cancellationToken.Register(
++++++++++++()+=>
++++++++++++{
++++++++++++++++removeHandler(handler);
++++++++++++++++taskCompletionSource.TrySetCanceled();
++++++++++++});
++++}

++++return+taskCompletionSource.Task;
}|1740617|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is a more modern awaitable, Task Parallel Library (TPL) based solution for .NET 4.5 and above.

<h1>Usage Example</h1>

<pre><code>try
{
 var exitCode = await StartProcess(
 "dotnet", 
 "--version", 
 @"C:\",
 10000, 
 Console.Out, 
 Console.Out);
 Console.WriteLine($"Process Exited with Exit Code {exitCode}!");
}
catch (TaskCanceledException)
{
 Console.WriteLine("Process Timed Out!");
}
</code></pre>

<h1>Implementation</h1>

<pre><code>public static async Task&lt;int&gt; StartProcess(
 string filename,
 string arguments,
 string workingDirectory= null,
 int? timeout = null,
 TextWriter outputTextWriter = null,
 TextWriter errorTextWriter = null)
{
 using (var process = new Process()
 {
 StartInfo = new ProcessStartInfo()
 {
 CreateNoWindow = true,
 Arguments = arguments,
 FileName = filename,
 RedirectStandardOutput = outputTextWriter != null,
 RedirectStandardError = errorTextWriter != null,
 UseShellExecute = false,
 WorkingDirectory = workingDirectory
 }
 })
 {
 var cancellationTokenSource = timeout.HasValue ?
 new CancellationTokenSource(timeout.Value) :
 new CancellationTokenSource();

 process.Start();

 var tasks = new List&lt;Task&gt;(3) { process.WaitForExitAsync(cancellationTokenSource.Token) };
 if (outputTextWriter != null)
 {
 tasks.Add(ReadAsync(
 x =&gt;
 {
 process.OutputDataReceived += x;
 process.BeginOutputReadLine();
 },
 x =&gt; process.OutputDataReceived -= x,
 outputTextWriter,
 cancellationTokenSource.Token));
 }

 if (errorTextWriter != null)
 {
 tasks.Add(ReadAsync(
 x =&gt;
 {
 process.ErrorDataReceived += x;
 process.BeginErrorReadLine();
 },
 x =&gt; process.ErrorDataReceived -= x,
 errorTextWriter,
 cancellationTokenSource.Token));
 }

 await Task.WhenAll(tasks);
 return process.ExitCode;
 }
}

/// &lt;summary&gt;
/// Waits asynchronously for the process to exit.
/// &lt;/summary&gt;
/// &lt;param name="process"&gt;The process to wait for cancellation.&lt;/param&gt;
/// &lt;param name="cancellationToken"&gt;A cancellation token. If invoked, the task will return
/// immediately as cancelled.&lt;/param&gt;
/// &lt;returns&gt;A Task representing waiting for the process to end.&lt;/returns&gt;
public static Task WaitForExitAsync(
 this Process process,
 CancellationToken cancellationToken = default(CancellationToken))
{
 process.EnableRaisingEvents = true;

 var taskCompletionSource = new TaskCompletionSource&lt;object&gt;();

 EventHandler handler = null;
 handler = (sender, args) =&gt;
 {
 process.Exited -= handler;
 taskCompletionSource.TrySetResult(null);
 };
 process.Exited += handler;

 if (cancellationToken != default(CancellationToken))
 {
 cancellationToken.Register(
 () =&gt;
 {
 process.Exited -= handler;
 taskCompletionSource.TrySetCanceled();
 });
 }

 return taskCompletionSource.Task;
}

/// &lt;summary&gt;
/// Reads the data from the specified data recieved event and writes it to the
/// &lt;paramref name="textWriter"/&gt;.
/// &lt;/summary&gt;
/// &lt;param name="addHandler"&gt;Adds the event handler.&lt;/param&gt;
/// &lt;param name="removeHandler"&gt;Removes the event handler.&lt;/param&gt;
/// &lt;param name="textWriter"&gt;The text writer.&lt;/param&gt;
/// &lt;param name="cancellationToken"&gt;The cancellation token.&lt;/param&gt;
/// &lt;returns&gt;A task representing the asynchronous operation.&lt;/returns&gt;
public static Task ReadAsync(
 this Action&lt;DataReceivedEventHandler&gt; addHandler,
 Action&lt;DataReceivedEventHandler&gt; removeHandler,
 TextWriter textWriter,
 CancellationToken cancellationToken = default(CancellationToken))
{
 var taskCompletionSource = new TaskCompletionSource&lt;object&gt;();

 DataReceivedEventHandler handler = null;
 handler = new DataReceivedEventHandler(
 (sender, e) =&gt;
 {
 if (e.Data == null)
 {
 removeHandler(handler);
 taskCompletionSource.TrySetResult(null);
 }
 else
 {
 textWriter.WriteLine(e.Data);
 }
 });

 addHandler(handler);

 if (cancellationToken != default(CancellationToken))
 {
 cancellationToken.Register(
 () =&gt;
 {
 removeHandler(handler);
 taskCompletionSource.TrySetCanceled();
 });
 }

 return taskCompletionSource.Task;
}
</code></pre>

blocks|key|1740719|text|上面的答案都不能解决这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1740720|Rob解决方案挂起，'Mark+Byer‘解决方案得到已处理的异常。(我尝试了其他答案的“解决方案”)。|1740721|所以我决定提出另一个解决方案：|1740722|public+void+GetProcessOutputWithTimeout(Process+process,+int+timeoutSec,+CancellationToken+token,+out+string+output,+out+int+exitCode)
{
++++string+outputLocal+=+"";++int+localExitCode+=+-1;
++++var+task+=+System.Threading.Tasks.Task.Factory.StartNew(()+=>
++++{
++++++++outputLocal+=+process.StandardOutput.ReadToEnd();
++++++++process.WaitForExit();
++++++++localExitCode+=+process.ExitCode;
++++},+token);

++++if+(task.Wait(timeoutSec,+token))
++++{
++++++++output+=+outputLocal;
++++++++exitCode+=+localExitCode;
++++}
++++else
++++{
++++++++exitCode+=+-1;
++++++++output+=+"";
++++}
}

using+(var+process+=+new+Process())
{
++++process.StartInfo+=+...;
++++process.Start();
++++string+outputUnicode;+int+exitCode;
++++GetProcessOutputWithTimeout(process,+PROCESS_TIMEOUT,+out+outputUnicode,+out+exitCode);
}|code-block|syntax|javascript|1740723|这段代码经过调试，运行良好。|1740724|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

None of the answers above is doing the job.

Rob solution hangs and 'Mark Byers' solution get the disposed exception.(I tried the "solutions" of the other answers).

So I decided to suggest another solution:

<pre><code>public void GetProcessOutputWithTimeout(Process process, int timeoutSec, CancellationToken token, out string output, out int exitCode)
{
 string outputLocal = ""; int localExitCode = -1;
 var task = System.Threading.Tasks.Task.Factory.StartNew(() =&gt;
 {
 outputLocal = process.StandardOutput.ReadToEnd();
 process.WaitForExit();
 localExitCode = process.ExitCode;
 }, token);

 if (task.Wait(timeoutSec, token))
 {
 output = outputLocal;
 exitCode = localExitCode;
 }
 else
 {
 exitCode = -1;
 output = "";
 }
}

using (var process = new Process())
{
 process.StartInfo = ...;
 process.Start();
 string outputUnicode; int exitCode;
 GetProcessOutputWithTimeout(process, PROCESS_TIMEOUT, out outputUnicode, out exitCode);
}
</code></pre>

This code debugged and works perfectly.

blocks|key|1740844|text|引言|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1740845|目前接受的答案不起作用(抛出异常)，有太多的变通方法，但没有完整的代码。这显然是在浪费人们的时间，因为这是一个流行的问题。|1740846|结合Mark+Byer的答案和Karol+Tyl的答案，我编写了基于我想要如何使用Process.Start方法的完整代码。|1740847|用法|1740848|我已经使用它创建了git命令的进度对话框。我是这样使用它的：|1740849|++++private+bool+Run(string+fullCommand)
++++{
++++++++Error+=+"";
++++++++int+timeout+=+5000;

++++++++var+result+=+ProcessNoBS.Start(
++++++++++++filename:+@"C:\Program+Files\Git\cmd\git.exe",
++++++++++++arguments:+fullCommand,
++++++++++++timeoutInMs:+timeout,
++++++++++++workingDir:+@"C:\test");

++++++++if+(result.hasTimedOut)
++++++++{
++++++++++++Error+=+String.Format("Timeout+({0}+sec)",+timeout/1000);
++++++++++++return+false;
++++++++}

++++++++if+(result.ExitCode+!=+0)
++++++++{
++++++++++++Error+=+(String.IsNullOrWhiteSpace(result.stderr))+
++++++++++++++++?+result.stdout+:+result.stderr;
++++++++++++return+false;
++++++++}

++++++++return+true;
++++}|code-block|syntax|javascript|1740850|从理论上讲，您还可以组合stdout和stderr，但我还没有对此进行测试。|1740851|代码|1740852|public+struct+ProcessResult
{
++++public+string+stdout;
++++public+string+stderr;
++++public+bool+hasTimedOut;
++++private+int?+exitCode;

++++public+ProcessResult(bool+hasTimedOut+=+true)
++++{
++++++++this.hasTimedOut+=+hasTimedOut;
++++++++stdout+=+null;
++++++++stderr+=+null;
++++++++exitCode+=+null;
++++}

++++public+int+ExitCode
++++{
++++++++get+
++++++++{
++++++++++++if+(hasTimedOut)
++++++++++++++++throw+new+InvalidOperationException(
++++++++++++++++++++"There+was+no+exit+code+-+process+has+timed+out.");

++++++++++++return+(int)exitCode;
++++++++}
++++++++set
++++++++{
++++++++++++exitCode+=+value;
++++++++}
++++}
}

public+class+ProcessNoBS
{
++++public+static+ProcessResult+Start(string+filename,+string+arguments,
++++++++string+workingDir+=+null,+int+timeoutInMs+=+5000,
++++++++bool+combineStdoutAndStderr+=+false)
++++{
++++++++using+(AutoResetEvent+outputWaitHandle+=+new+AutoResetEvent(false))
++++++++using+(AutoResetEvent+errorWaitHandle+=+new+AutoResetEvent(false))
++++++++{
++++++++++++using+(var+process+=+new+Process())
++++++++++++{
++++++++++++++++var+info+=+new+ProcessStartInfo();

++++++++++++++++info.CreateNoWindow+=+true;
++++++++++++++++info.FileName+=+filename;
++++++++++++++++info.Arguments+=+arguments;
++++++++++++++++info.UseShellExecute+=+false;
++++++++++++++++info.RedirectStandardOutput+=+true;
++++++++++++++++info.RedirectStandardError+=+true;

++++++++++++++++if+(workingDir+!=+null)
++++++++++++++++++++info.WorkingDirectory+=+workingDir;

++++++++++++++++process.StartInfo+=+info;

++++++++++++++++StringBuilder+stdout+=+new+StringBuilder();
++++++++++++++++StringBuilder+stderr+=+combineStdoutAndStderr
++++++++++++++++++++?+stdout+:+new+StringBuilder();

++++++++++++++++var+result+=+new+ProcessResult();

++++++++++++++++try
++++++++++++++++{
++++++++++++++++++++process.OutputDataReceived+%2B=+(sender,+e)+=>
++++++++++++++++++++{
++++++++++++++++++++++++if+(e.Data+==+null)
++++++++++++++++++++++++++++outputWaitHandle.Set();
++++++++++++++++++++++++else
++++++++++++++++++++++++++++stdout.AppendLine(e.Data);
++++++++++++++++++++};
++++++++++++++++++++process.ErrorDataReceived+%2B=+(sender,+e)+=>
++++++++++++++++++++{
++++++++++++++++++++++++if+(e.Data+==+null)
++++++++++++++++++++++++++++errorWaitHandle.Set();
++++++++++++++++++++++++else
++++++++++++++++++++++++++++stderr.AppendLine(e.Data);
++++++++++++++++++++};

++++++++++++++++++++process.Start();

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

++++++++++++++++++++if+(process.WaitForExit(timeoutInMs))
++++++++++++++++++++++++result.ExitCode+=+process.ExitCode;
++++++++++++++++++++//+else+process+has+timed+out+
++++++++++++++++++++//+but+that's+already+default+ProcessResult

++++++++++++++++++++result.stdout+=+stdout.ToString();
++++++++++++++++++++if+(combineStdoutAndStderr)
++++++++++++++++++++++++result.stderr+=+null;
++++++++++++++++++++else
++++++++++++++++++++++++result.stderr+=+stderr.ToString();

++++++++++++++++++++return+result;
++++++++++++++++}
++++++++++++++++finally
++++++++++++++++{
++++++++++++++++++++outputWaitHandle.WaitOne(timeoutInMs);
++++++++++++++++++++errorWaitHandle.WaitOne(timeoutInMs);
++++++++++++++++}
++++++++++++}
++++++++}
++++}
}|1740853|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|11|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|L|7|14|8|@]|9|@]|A|$M|N]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

<h2>Introduction</h2>

Currently accepted answer doesn't work (throws exception) and there are too many workarounds but no complete code. This is obviously wasting lots of people's time because this is a popular question.

Combining Mark Byers' answer and Karol Tyl's answer I wrote full code based on how I want to use the Process.Start method.

<h2>Usage</h2>

I have used it to create progress dialog around git commands. This is how I've used it:

<pre><code> private bool Run(string fullCommand)
 {
 Error = "";
 int timeout = 5000;

 var result = ProcessNoBS.Start(
 filename: @"C:\Program Files\Git\cmd\git.exe",
 arguments: fullCommand,
 timeoutInMs: timeout,
 workingDir: @"C:\test");

 if (result.hasTimedOut)
 {
 Error = String.Format("Timeout ({0} sec)", timeout/1000);
 return false;
 }

 if (result.ExitCode != 0)
 {
 Error = (String.IsNullOrWhiteSpace(result.stderr)) 
 ? result.stdout : result.stderr;
 return false;
 }

 return true;
 }
</code></pre>

In theory you can also combine stdout and stderr, but I haven't tested that.

<h2>Code</h2>

<pre><code>public struct ProcessResult
{
 public string stdout;
 public string stderr;
 public bool hasTimedOut;
 private int? exitCode;

 public ProcessResult(bool hasTimedOut = true)
 {
 this.hasTimedOut = hasTimedOut;
 stdout = null;
 stderr = null;
 exitCode = null;
 }

 public int ExitCode
 {
 get 
 {
 if (hasTimedOut)
 throw new InvalidOperationException(
 "There was no exit code - process has timed out.");

 return (int)exitCode;
 }
 set
 {
 exitCode = value;
 }
 }
}

public class ProcessNoBS
{
 public static ProcessResult Start(string filename, string arguments,
 string workingDir = null, int timeoutInMs = 5000,
 bool combineStdoutAndStderr = false)
 {
 using (AutoResetEvent outputWaitHandle = new AutoResetEvent(false))
 using (AutoResetEvent errorWaitHandle = new AutoResetEvent(false))
 {
 using (var process = new Process())
 {
 var info = new ProcessStartInfo();

 info.CreateNoWindow = true;
 info.FileName = filename;
 info.Arguments = arguments;
 info.UseShellExecute = false;
 info.RedirectStandardOutput = true;
 info.RedirectStandardError = true;

 if (workingDir != null)
 info.WorkingDirectory = workingDir;

 process.StartInfo = info;

 StringBuilder stdout = new StringBuilder();
 StringBuilder stderr = combineStdoutAndStderr
 ? stdout : new StringBuilder();

 var result = new ProcessResult();

 try
 {
 process.OutputDataReceived += (sender, e) =&gt;
 {
 if (e.Data == null)
 outputWaitHandle.Set();
 else
 stdout.AppendLine(e.Data);
 };
 process.ErrorDataReceived += (sender, e) =&gt;
 {
 if (e.Data == null)
 errorWaitHandle.Set();
 else
 stderr.AppendLine(e.Data);
 };

 process.Start();

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

 if (process.WaitForExit(timeoutInMs))
 result.ExitCode = process.ExitCode;
 // else process has timed out 
 // but that's already default ProcessResult

 result.stdout = stdout.ToString();
 if (combineStdoutAndStderr)
 result.stderr = null;
 else
 result.stderr = stderr.ToString();

 return result;
 }
 finally
 {
 outputWaitHandle.WaitOne(timeoutInMs);
 errorWaitHandle.WaitOne(timeoutInMs);
 }
 }
 }
 }
}
</code></pre>

blocks|key|1525963|text|我知道这已经是老生常谈了，但是，在读完整页后，没有一个解决方案对我有效，尽管我没有尝试Muhammad+Rehan，因为代码有点难以理解，尽管我猜他是在正确的道路上。当我说它不能工作时，这并不完全正确，有时它会工作得很好，我猜这与EOF标记之前的输出长度有关。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1525964|无论如何，对我有效的解决方案是使用不同的线程来读取StandardOutput和StandardError并写入消息。|1525965|++++++++StreamWriter+sw+=+null;
++++++++var+queue+=+new+ConcurrentQueue<string>();

++++++++var+flushTask+=+new+System.Timers.Timer(50);
++++++++flushTask.Elapsed+%2B=+(s,+e)+=>
++++++++{
++++++++++++while+(!queue.IsEmpty)
++++++++++++{
++++++++++++++++string+line+=+null;
++++++++++++++++if+(queue.TryDequeue(out+line))
++++++++++++++++++++sw.WriteLine(line);
++++++++++++}
++++++++++++sw.FlushAsync();
++++++++};
++++++++flushTask.Start();

++++++++using+(var+process+=+new+Process())
++++++++{
++++++++++++try
++++++++++++{
++++++++++++++++process.StartInfo.FileName+=+@"...";
++++++++++++++++process.StartInfo.Arguments+=+$"...";
++++++++++++++++process.StartInfo.UseShellExecute+=+false;
++++++++++++++++process.StartInfo.RedirectStandardOutput+=+true;
++++++++++++++++process.StartInfo.RedirectStandardError+=+true;

++++++++++++++++process.Start();

++++++++++++++++var+outputRead+=+Task.Run(()+=>
++++++++++++++++{
++++++++++++++++++++while+(!process.StandardOutput.EndOfStream)
++++++++++++++++++++{
++++++++++++++++++++++++queue.Enqueue(process.StandardOutput.ReadLine());
++++++++++++++++++++}
++++++++++++++++});

++++++++++++++++var+errorRead+=+Task.Run(()+=>
++++++++++++++++{
++++++++++++++++++++while+(!process.StandardError.EndOfStream)
++++++++++++++++++++{
++++++++++++++++++++++++queue.Enqueue(process.StandardError.ReadLine());
++++++++++++++++++++}
++++++++++++++++});

++++++++++++++++var+timeout+=+new+TimeSpan(hours:+0,+minutes:+10,+seconds:+0);

++++++++++++++++if+(Task.WaitAll(new[]+{+outputRead,+errorRead+},+timeout)+&&
++++++++++++++++++++process.WaitForExit((int)timeout.TotalMilliseconds))
++++++++++++++++{
++++++++++++++++++++if+(process.ExitCode+!=+0)
++++++++++++++++++++{
++++++++++++++++++++++++throw+new+Exception($"Failed+run...+blah+blah");
++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++throw+new+Exception($"process+timed+out+after+waiting+{timeout}");
++++++++++++++++}
++++++++++++}
++++++++++++catch+(Exception+e)
++++++++++++{
++++++++++++++++throw+new+Exception($"Failed+to+succesfully+run+the+process.....",+e);
++++++++++++}
++++++++}
++++}|code-block|syntax|javascript|1525966|希望这能帮助一些人，谁认为这可能是如此之难！|1525967|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I know that this is supper old but, after reading this whole page none of the solutions was working for me, although I didn't try Muhammad Rehan as the code was a little hard to follow, although I guess he was on the right track. When I say it didn't work that's not entirely true, sometimes it would work fine, I guess it is something to do with the length of the output before an EOF mark.

Anyway, the solution that worked for me was to use different threads to read the StandardOutput and StandardError and write the messages.

<pre><code> StreamWriter sw = null;
 var queue = new ConcurrentQueue&lt;string&gt;();

 var flushTask = new System.Timers.Timer(50);
 flushTask.Elapsed += (s, e) =&gt;
 {
 while (!queue.IsEmpty)
 {
 string line = null;
 if (queue.TryDequeue(out line))
 sw.WriteLine(line);
 }
 sw.FlushAsync();
 };
 flushTask.Start();

 using (var process = new Process())
 {
 try
 {
 process.StartInfo.FileName = @"...";
 process.StartInfo.Arguments = $"...";
 process.StartInfo.UseShellExecute = false;
 process.StartInfo.RedirectStandardOutput = true;
 process.StartInfo.RedirectStandardError = true;

 process.Start();

 var outputRead = Task.Run(() =&gt;
 {
 while (!process.StandardOutput.EndOfStream)
 {
 queue.Enqueue(process.StandardOutput.ReadLine());
 }
 });

 var errorRead = Task.Run(() =&gt;
 {
 while (!process.StandardError.EndOfStream)
 {
 queue.Enqueue(process.StandardError.ReadLine());
 }
 });

 var timeout = new TimeSpan(hours: 0, minutes: 10, seconds: 0);

 if (Task.WaitAll(new[] { outputRead, errorRead }, timeout) &amp;&amp;
 process.WaitForExit((int)timeout.TotalMilliseconds))
 {
 if (process.ExitCode != 0)
 {
 throw new Exception($"Failed run... blah blah");
 }
 }
 else
 {
 throw new Exception($"process timed out after waiting {timeout}");
 }
 }
 catch (Exception e)
 {
 throw new Exception($"Failed to succesfully run the process.....", e);
 }
 }
 }
</code></pre>

Hope this helps someone, who thought this could be so hard!

blocks|key|1526032|text|为https://stackoverflow.com/a/17600012/4151626提供的EM0积分|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1526033|对于我的应用程序，其他解决方案(包括EM0)仍然死锁，原因是内部超时以及衍生的应用程序同时使用StandardOutput和StandardError。以下是对我有效的方法：|1526034|Process+p+=+new+Process()
{
++StartInfo+=+new+ProcessStartInfo()
++{
++++FileName+=+exe,
++++Arguments+=+args,
++++UseShellExecute+=+false,
++++RedirectStandardOutput+=+true,
++++RedirectStandardError+=+true
++}
};
p.Start();

string+cv_error+=+null;
Thread+et+=+new+Thread(()+=>+{+cv_error+=+p.StandardError.ReadToEnd();+});
et.Start();

string+cv_out+=+null;
Thread+ot+=+new+Thread(()+=>+{+cv_out+=+p.StandardOutput.ReadToEnd();+});
ot.Start();

p.WaitForExit();
ot.Join();
et.Join();|code-block|syntax|javascript|1526035|编辑:将StartInfo的初始化添加到代码示例中|1526036|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/17600012/4151626|1|https://stackoverflow.com/users/1536933/em0^0|1|18|0|1C|3|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]|$A|10|B|11|1|12]]|C|$]]|$1|D|3|E|5|6|7|13|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|14|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

Credit to <a href="https://stackoverflow.com/users/1536933/em0" title="EM0">EM0</a> for <a href="https://stackoverflow.com/a/17600012/4151626">https://stackoverflow.com/a/17600012/4151626</a>

The other solutions (including EM0's) still deadlocked for my application, due to internal timeouts and the use of both StandardOutput and StandardError by the spawned application. Here is what worked for me:

<pre><code>Process p = new Process()
{
 StartInfo = new ProcessStartInfo()
 {
 FileName = exe,
 Arguments = args,
 UseShellExecute = false,
 RedirectStandardOutput = true,
 RedirectStandardError = true
 }
};
p.Start();

string cv_error = null;
Thread et = new Thread(() =&gt; { cv_error = p.StandardError.ReadToEnd(); });
et.Start();

string cv_out = null;
Thread ot = new Thread(() =&gt; { cv_out = p.StandardOutput.ReadToEnd(); });
ot.Start();

p.WaitForExit();
ot.Join();
et.Join();
</code></pre>

Edit: added initialization of StartInfo to code sample

blocks|key|1526087|text|我认为使用异步，可能会有一个更优雅的解决方案，即使同时使用standardOutput和standardError也不会出现死锁：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1526088|using+(Process+process+=+new+Process())
{
++++process.StartInfo.FileName+=+filename;
++++process.StartInfo.Arguments+=+arguments;
++++process.StartInfo.UseShellExecute+=+false;
++++process.StartInfo.RedirectStandardOutput+=+true;
++++process.StartInfo.RedirectStandardError+=+true;

++++process.Start();

++++var+tStandardOutput+=+process.StandardOutput.ReadToEndAsync();
++++var+tStandardError+=+process.StandardError.ReadToEndAsync();

++++if+(process.WaitForExit(timeout))
++++{
++++++++string+output+=+await+tStandardOutput;
++++++++string+errors+=+await+tStandardError;

++++++++//+Process+completed.+Check+process.ExitCode+here.
++++}
++++else
++++{
++++++++//+Timed+out.
++++}
}|code-block|syntax|javascript|1526089|它是基于Mark+Byer回答。如果不使用异步方法，则可以使用string+output+=+tStandardOutput.result;而不是await|offset|length|style|CODE|1526090|entityMap^0|0|0|V|13|21|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

I think with async, it is possible to have a more elegant solution and not having deadlocks even when using both standardOutput and standardError:

<pre><code>using (Process process = new Process())
{
 process.StartInfo.FileName = filename;
 process.StartInfo.Arguments = arguments;
 process.StartInfo.UseShellExecute = false;
 process.StartInfo.RedirectStandardOutput = true;
 process.StartInfo.RedirectStandardError = true;

 process.Start();

 var tStandardOutput = process.StandardOutput.ReadToEndAsync();
 var tStandardError = process.StandardError.ReadToEndAsync();

 if (process.WaitForExit(timeout))
 {
 string output = await tStandardOutput;
 string errors = await tStandardError;

 // Process completed. Check process.ExitCode here.
 }
 else
 {
 // Timed out.
 }
}
</code></pre>

It is base on Mark Byers answer.
If you are not in an async method, you can use <code>string output = tStandardOutput.result;</code> instead of <code>await</code>

blocks|key|1526199|text|让我们将此处发布的示例代码称为重定向器，并将另一个程序称为重定向程序。如果是我的话，我可能会写一个测试重定向的程序，用来复制这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1526200|所以我就这么做了。对于测试数据，我使用了ECMA-334PDF语言规范；它大约是5MB。以下是其中的重要部分。|1526201|StreamReader+stream+=+null;
try+{+stream+=+new+StreamReader(Path);+}
catch+(Exception+ex)
{
++++Console.Error.WriteLine("Input+open+error:+"+%2B+ex.Message);
++++return;
}
Console.SetIn(stream);
int+datasize+=+0;
try
{
++++string+record+=+Console.ReadLine();
++++while+(record+!=+null)
++++{
++++++++datasize+%2B=+record.Length+%2B+2;
++++++++record+=+Console.ReadLine();
++++++++Console.WriteLine(record);
++++}
}
catch+(Exception+ex)
{
++++Console.Error.WriteLine($"Error:+{ex.Message}");
++++return;
}|code-block|syntax|javascript|1526202|数据大小值与实际文件大小不匹配，但这并不重要。目前还不清楚PDF文件是否总是在行尾同时使用CR和LF，但这对此并不重要。您可以使用任何其他大型文本文件进行测试。|1526203|因此，示例重定向器代码在我写入大量数据时挂起，但在我写入少量数据时不会挂起。|1526204|我试图以某种方式跟踪代码的执行，但我做不到。我注释掉了重定向程序中禁止为重定向程序创建控制台的行，以尝试获得单独的控制台窗口，但我做不到。|1526205|然后我找到了How+to+start+a+console+app+in+a+new+window,+the+parent’s+window,+or+no+window。因此，当一个控制台程序启动另一个没有ShellExecute的控制台程序时，显然我们不能(很容易)拥有一个单独的控制台，而且由于ShellExecute不支持重定向，我们必须共享一个控制台，即使我们没有为另一个进程指定窗口。|offset|length|1526206|我假设如果重定向的程序填满了某个缓冲区，那么它必须等待数据被读取，如果此时没有数据被重定向器读取，那么它就是死锁。|1526207|解决方案是不使用ReadToEnd，在写入数据时读取数据，但不一定要使用异步读取。解决方案可以非常简单。以下内容适用于我的5MB+PDF。|1526208|ProcessStartInfo+info+=+new+ProcessStartInfo(TheProgram);
info.CreateNoWindow+=+true;
info.WindowStyle+=+System.Diagnostics.ProcessWindowStyle.Hidden;
info.RedirectStandardOutput+=+true;
info.UseShellExecute+=+false;
Process+p+=+Process.Start(info);
string+record+=+p.StandardOutput.ReadLine();
while+(record+!=+null)
{
++++Console.WriteLine(record);
++++record+=+p.StandardOutput.ReadLine();
}
p.WaitForExit();|1526209|另一种可能是使用GUI程序进行重定向。前面的代码在WPF应用程序中工作，除非有明显的修改。|1526210|entityMap|0|LINK|mutability|MUTABLE|url|https://blogs.msdn.microsoft.com/jmstall/2006/09/28/how-to-start-a-console-app-in-a-new-window-the-parents-window-or-no-window^0|0|0|0|0|0|0|6|25|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1E|8|@]|9|@$Q|1F|R|1G|1|1H]]|A|$]]|$1|S|3|T|5|6|7|1I|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1J|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1K|8|@]|9|@]|A|$G|H]]|$1|Y|3|Z|5|6|7|1L|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]]]

Let us call the sample code posted here the redirector and the other program the redirected. If it were me then I would probably write a test redirected program that can be used to duplicate the problem.

So I did. For test data I used the ECMA-334 C# Language Specificationv PDF; it is about 5MB. The following is the important part of that.

<pre><code>StreamReader stream = null;
try { stream = new StreamReader(Path); }
catch (Exception ex)
{
 Console.Error.WriteLine("Input open error: " + ex.Message);
 return;
}
Console.SetIn(stream);
int datasize = 0;
try
{
 string record = Console.ReadLine();
 while (record != null)
 {
 datasize += record.Length + 2;
 record = Console.ReadLine();
 Console.WriteLine(record);
 }
}
catch (Exception ex)
{
 Console.Error.WriteLine($"Error: {ex.Message}");
 return;
}
</code></pre>

The datasize value does not match the actual file size but that does not matter. It is not clear if a PDF file always uses both CR and LF at the end of lines but that does not matter for this. You can use any other large text file to test with.

Using that the sample redirector code hangs when I write the large amount of data but not when I write a small amount.

I tried very much to somehow trace the execution of that code and I could not. I commented out the lines of the redirected program that disabled creation of a console for the redirected program to try to get a separate console window but I could not.

Then I found <a href="https://blogs.msdn.microsoft.com/jmstall/2006/09/28/how-to-start-a-console-app-in-a-new-window-the-parents-window-or-no-window" rel="nofollow noreferrer">How to start a console app in a new window, the parent’s window, or no window</a>. So apparently we cannot (easily) have a separate console when one console program starts another console program without ShellExecute and since ShellExecute does not support redirection we must share a console, even if we specify no window for the other process.

I assume that if the redirected program fills up a buffer somewhere then it must wait for the data to be read and if at that point no data is read by the redirector then it is a deadlock.

The solution is to not use ReadToEnd and to read the data while the data is being written but it is not necessary to use asynchronous reads. The solution can be quite simple. The following works for me with the 5 MB PDF.

<pre><code>ProcessStartInfo info = new ProcessStartInfo(TheProgram);
info.CreateNoWindow = true;
info.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
info.RedirectStandardOutput = true;
info.UseShellExecute = false;
Process p = Process.Start(info);
string record = p.StandardOutput.ReadLine();
while (record != null)
{
 Console.WriteLine(record);
 record = p.StandardOutput.ReadLine();
}
p.WaitForExit();
</code></pre>

Another possibility is to use a GUI program to do the redirection. The preceding code works in a WPF application except with obvious modifications.

blocks|key|1526263|text|我最终使用了解决方法来避免所有的复杂性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1526264|var+outputFile+=+Path.GetTempFileName();
info+=+new+System.Diagnostics.ProcessStartInfo("TheProgram.exe",+String.Join("+",+args)+%2B+"+>+"+%2B+outputFile+%2B+"+2>&1");
info.CreateNoWindow+=+true;
info.WindowStyle+=+System.Diagnostics.ProcessWindowStyle.Hidden;
info.UseShellExecute+=+false;
System.Diagnostics.Process+p+=+System.Diagnostics.Process.Start(info);
p.WaitForExit();
Console.WriteLine(File.ReadAllText(outputFile));+//need+the+StandardOutput+contents|code-block|syntax|javascript|1526265|因此，我创建了一个临时文件，使用>+outputfile+>+2>&1将输出和错误重定向到该文件，然后在该过程完成后读取该文件。|offset|length|style|CODE|1526266|其他解决方案适用于您想要对输出做其他事情的场景，但对于简单的事情，这就避免了大量的复杂性。|1526267|entityMap^0|0|0|G|J|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Workaround I ended up using to avoid all the complexity:

<pre><code>var outputFile = Path.GetTempFileName();
info = new System.Diagnostics.ProcessStartInfo("TheProgram.exe", String.Join(" ", args) + " &gt; " + outputFile + " 2&gt;&amp;1");
info.CreateNoWindow = true;
info.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
info.UseShellExecute = false;
System.Diagnostics.Process p = System.Diagnostics.Process.Start(info);
p.WaitForExit();
Console.WriteLine(File.ReadAllText(outputFile)); //need the StandardOutput contents
</code></pre>

So I create a temp file, redirect both the output and error to it by using <code>&gt; outputfile &gt; 2&gt;&amp;1</code> and then just read the file after the process has finished.

The other solutions are fine for scenarios where you want to do other stuff with the output, but for simple stuff this avoids a lot of complexity.

blocks|key|1741364|text|我已经阅读了许多答案，并提出了我自己的答案。我不确定这个在任何情况下都会修复，但它可以在我的环境中修复。我只是没有使用WaitForExit，而是在输出和错误结束信号上都使用WaitHandle.WaitAll。如果有人看到可能存在的问题，我会很高兴的。也不知道这是否能帮到别人。对我来说，这更好，因为不使用超时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1741365|private+static+int+DoProcess(string+workingDir,+string+fileName,+string+arguments)
{
++++int+exitCode;
++++using+(var+process+=+new+Process
++++{
++++++++StartInfo+=
++++++++{
++++++++++++WorkingDirectory+=+workingDir,
++++++++++++WindowStyle+=+ProcessWindowStyle.Hidden,
++++++++++++CreateNoWindow+=+true,
++++++++++++UseShellExecute+=+false,
++++++++++++FileName+=+fileName,
++++++++++++Arguments+=+arguments,
++++++++++++RedirectStandardError+=+true,
++++++++++++RedirectStandardOutput+=+true
++++++++},
++++++++EnableRaisingEvents+=+true
++++})
++++{
++++++++using+(var+outputWaitHandle+=+new+AutoResetEvent(false))
++++++++using+(var+errorWaitHandle+=+new+AutoResetEvent(false))
++++++++{
++++++++++++process.OutputDataReceived+%2B=+(sender,+args)+=>
++++++++++++{
++++++++++++++++//+ReSharper+disable+once+AccessToDisposedClosure
++++++++++++++++if+(args.Data+!=+null)+Debug.Log(args.Data);
++++++++++++++++else+outputWaitHandle.Set();
++++++++++++};
++++++++++++process.ErrorDataReceived+%2B=+(sender,+args)+=>
++++++++++++{
++++++++++++++++//+ReSharper+disable+once+AccessToDisposedClosure
++++++++++++++++if+(args.Data+!=+null)+Debug.LogError(args.Data);
++++++++++++++++else+errorWaitHandle.Set();
++++++++++++};

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

++++++++++++WaitHandle.WaitAll(new+WaitHandle[]+{+outputWaitHandle,+errorWaitHandle+});

++++++++++++exitCode+=+process.ExitCode;
++++++++}
++++}
++++return+exitCode;
}|code-block|syntax|javascript|1741366|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I've read many of the answers and made my own. Not sure this one will fix in any case, but it fixes in my environment. I'm just not using WaitForExit and use WaitHandle.WaitAll on both output &amp; error end signals. I will be glad, if someone will see possible problems with that. Or if it will help someone. For me it's better because not uses timeouts.

<pre><code>private static int DoProcess(string workingDir, string fileName, string arguments)
{
 int exitCode;
 using (var process = new Process
 {
 StartInfo =
 {
 WorkingDirectory = workingDir,
 WindowStyle = ProcessWindowStyle.Hidden,
 CreateNoWindow = true,
 UseShellExecute = false,
 FileName = fileName,
 Arguments = arguments,
 RedirectStandardError = true,
 RedirectStandardOutput = true
 },
 EnableRaisingEvents = true
 })
 {
 using (var outputWaitHandle = new AutoResetEvent(false))
 using (var errorWaitHandle = new AutoResetEvent(false))
 {
 process.OutputDataReceived += (sender, args) =&gt;
 {
 // ReSharper disable once AccessToDisposedClosure
 if (args.Data != null) Debug.Log(args.Data);
 else outputWaitHandle.Set();
 };
 process.ErrorDataReceived += (sender, args) =&gt;
 {
 // ReSharper disable once AccessToDisposedClosure
 if (args.Data != null) Debug.LogError(args.Data);
 else errorWaitHandle.Set();
 };

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

 WaitHandle.WaitAll(new WaitHandle[] { outputWaitHandle, errorWaitHandle });

 exitCode = process.ExitCode;
 }
 }
 return exitCode;
}
</code></pre>

I have the following code:
<pre><code>info = new System.Diagnostics.ProcessStartInfo(&quot;TheProgram.exe&quot;, String.Join(&quot; &quot;, args));
info.CreateNoWindow = true;
info.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
info.RedirectStandardOutput = true;
info.UseShellExecute = false;
System.Diagnostics.Process p = System.Diagnostics.Process.Start(info);
p.WaitForExit();
Console.WriteLine(p.StandardOutput.ReadToEnd()); //need the StandardOutput contents
</code></pre>
I know that the output from the process I am starting is around 7MB long. Running it in the Windows console works fine. Unfortunately programmatically this hangs indefinitely at <code>WaitForExit</code>. Note also this code does NOT hang for smaller outputs (like 3KB).
Is it possible that the internal <code>StandardOutput</code> in <code>ProcessStartInfo</code> can't buffer 7MB? If so, what should I do instead? If not, what am I doing wrong?

ProcessStartInfo hanging on "WaitForExit"? Why?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我有以下代码：info = new System.Diagnostics.ProcessStartInfo("TheProgram.exe", String.Join(" ", args));info.CreateNoWindow = true;info.WindowStyle = System.Diagnostics...

问ProcessStartInfo挂在"WaitForExit“上？为什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问ProcessStartInfo挂在"WaitForExit“上？为什么？EN