blocks|key|344330|text|Process.Start()只启动进程，它不会等到它完成，所以将它设为async没有多大意义。如果你仍然想这样做，你可以做一些像await+Task.Run(()+=>+Process.Start(fileName))这样的事情。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|344331|但是，如果您希望异步等待进程完成，则可以结合使用the+Exited+event和TaskCompletionSource|344332|static+Task<int>+RunProcessAsync(string+fileName)
{
++++var+tcs+=+new+TaskCompletionSource<int>();

++++var+process+=+new+Process
++++{
++++++++StartInfo+=+{+FileName+=+fileName+},
++++++++EnableRaisingEvents+=+true
++++};

++++process.Exited+%2B=+(sender,+args)+=>
++++{
++++++++tcs.SetResult(process.ExitCode);
++++++++process.Dispose();
++++};

++++process.Start();

++++return+tcs.Task;
}|code-block|syntax|javascript|344333|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.diagnostics.process.exited|1|http://msdn.microsoft.com/en-us/library/dd449174.aspx^0|0|F|10|5|1T|19|0|S|6|15|K|O|G|0|15|K|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@$9|18|A|19|1|1A]|$9|1B|A|1C|1|1D]]|E|$]]|$1|H|3|I|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

<code>Process.Start()</code> only starts the process, it doesn't wait until it finishes, so it doesn't make much sense to make it <code>async</code>. If you still want to do it, you can do something like <code>await Task.Run(() =&gt; Process.Start(fileName))</code>.

But, if you want to asynchronously wait for the process to finish, you can use <a href="http://msdn.microsoft.com/en-us/library/system.diagnostics.process.exited" rel="noreferrer">the <code>Exited</code> event</a> together with <a href="http://msdn.microsoft.com/en-us/library/dd449174.aspx" rel="noreferrer"><code>TaskCompletionSource</code></a>:

<pre><code>static Task&lt;int&gt; RunProcessAsync(string fileName)
{
 var tcs = new TaskCompletionSource&lt;int&gt;();

 var process = new Process
 {
 StartInfo = { FileName = fileName },
 EnableRaisingEvents = true
 };

 process.Exited += (sender, args) =&gt;
 {
 tcs.SetResult(process.ExitCode);
 process.Dispose();
 };

 process.Start();

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

blocks|key|344385|text|以下是我基于svick's+answer的观点。它添加了输出重定向、退出代码保留和稍微更好的错误处理(即使Process对象无法启动，也会将其释放)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|344386|public+static+async+Task<int>+RunProcessAsync(string+fileName,+string+args)
{
++++using+(var+process+=+new+Process
++++{
++++++++StartInfo+=
++++++++{
++++++++++++FileName+=+fileName,+Arguments+=+args,
++++++++++++UseShellExecute+=+false,+CreateNoWindow+=+true,
++++++++++++RedirectStandardOutput+=+true,+RedirectStandardError+=+true
++++++++},
++++++++EnableRaisingEvents+=+true
++++})
++++{
++++++++return+await+RunProcessAsync(process).ConfigureAwait(false);
++++}
}++++
private+static+Task<int>+RunProcessAsync(Process+process)
{
++++var+tcs+=+new+TaskCompletionSource<int>();

++++process.Exited+%2B=+(s,+ea)+=>+tcs.SetResult(process.ExitCode);
++++process.OutputDataReceived+%2B=+(s,+ea)+=>+Console.WriteLine(ea.Data);
++++process.ErrorDataReceived+%2B=+(s,+ea)+=>+Console.WriteLine("ERR:+"+%2B+ea.Data);

++++bool+started+=+process.Start();
++++if+(!started)
++++{
++++++++//you+may+allow+for+the+process+to+be+re-used+(started+=+false)+
++++++++//but+I'm+not+sure+about+the+guarantees+of+the+Exited+event+in+such+a+case
++++++++throw+new+InvalidOperationException("Could+not+start+process:+"+%2B+process);
++++}

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

++++return+tcs.Task;
}|code-block|syntax|javascript|344387|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/10789196/67824^0|1H|7|6|E|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]]]]

Here's my take, based on <a href="https://stackoverflow.com/a/10789196/67824">svick's answer</a>. It adds output redirection, exit code retention, and slightly better error handling (disposing the <code>Process</code> object even if it could not be started):

<pre><code>public static async Task&lt;int&gt; RunProcessAsync(string fileName, string args)
{
 using (var process = new Process
 {
 StartInfo =
 {
 FileName = fileName, Arguments = args,
 UseShellExecute = false, CreateNoWindow = true,
 RedirectStandardOutput = true, RedirectStandardError = true
 },
 EnableRaisingEvents = true
 })
 {
 return await RunProcessAsync(process).ConfigureAwait(false);
 }
} 
private static Task&lt;int&gt; RunProcessAsync(Process process)
{
 var tcs = new TaskCompletionSource&lt;int&gt;();

 process.Exited += (s, ea) =&gt; tcs.SetResult(process.ExitCode);
 process.OutputDataReceived += (s, ea) =&gt; Console.WriteLine(ea.Data);
 process.ErrorDataReceived += (s, ea) =&gt; Console.WriteLine("ERR: " + ea.Data);

 bool started = process.Start();
 if (!started)
 {
 //you may allow for the process to be re-used (started = false) 
 //but I'm not sure about the guarantees of the Exited event in such a case
 throw new InvalidOperationException("Could not start process: " + process);
 }

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

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

blocks|key|344439|text|这是另一种方法。与svick和Ohad's答案的概念类似，但在Process类型上使用扩展方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|344440|扩展方法：|344441|public+static+Task+RunAsync(this+Process+process)
{
++++var+tcs+=+new+TaskCompletionSource<object>();
++++process.EnableRaisingEvents+=+true;
++++process.Exited+%2B=+(s,+e)+=>+tcs.TrySetResult(null);
++++//+not+sure+on+best+way+to+handle+false+being+returned
++++if+(!process.Start())+tcs.SetException(new+Exception("Failed+to+start+process."));
++++return+tcs.Task;
}|code-block|syntax|javascript|344442|包含方法中的示例用例：|344443|public+async+Task+ExecuteAsync(string+executablePath)
{
++++using+(var+process+=+new+Process())
++++{
++++++++//+configure+process
++++++++process.StartInfo.FileName+=+executablePath;
++++++++process.StartInfo.UseShellExecute+=+false;
++++++++process.StartInfo.CreateNoWindow+=+true;
++++++++//+run+process+asynchronously
++++++++await+process.RunAsync();
++++++++//+do+stuff+with+results
++++++++Console.WriteLine($"Process+finished+running+at+{process.ExitTime}+with+exit+code+{process.ExitCode}");
++++};//+dispose+process
}|344444|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/10789196/674237|1|https://stackoverflow.com/a/31492250/674237^0|V|7|9|5|0|F|6|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]|$9|16|A|17|1|18]]|E|$]]|$1|F|3|G|5|6|7|19|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]]]

Here's another approach. Similar concept to <a href="https://stackoverflow.com/a/10789196/674237">svick</a> and <a href="https://stackoverflow.com/a/31492250/674237">Ohad's</a> answers but using an extension method on the <code>Process</code> type.

Extension method:

<pre><code>public static Task RunAsync(this Process process)
{
 var tcs = new TaskCompletionSource&lt;object&gt;();
 process.EnableRaisingEvents = true;
 process.Exited += (s, e) =&gt; tcs.TrySetResult(null);
 // not sure on best way to handle false being returned
 if (!process.Start()) tcs.SetException(new Exception("Failed to start process."));
 return tcs.Task;
}
</code></pre>

Example use case in a containing method:

<pre><code>public async Task ExecuteAsync(string executablePath)
{
 using (var process = new Process())
 {
 // configure process
 process.StartInfo.FileName = executablePath;
 process.StartInfo.UseShellExecute = false;
 process.StartInfo.CreateNoWindow = true;
 // run process asynchronously
 await process.RunAsync();
 // do stuff with results
 Console.WriteLine($"Process finished running at {process.ExitTime} with exit code {process.ExitCode}");
 };// dispose process
}
</code></pre>

blocks|key|560501|text|我真的很担心进程的处理，如果等待异步退出呢?这是我的建议(基于前面的)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|560502|public+static+class+ProcessExtensions
{
++++public+static+Task+WaitForExitAsync(this+Process+process)
++++{
++++++++var+tcs+=+new+TaskCompletionSource<object>();
++++++++process.EnableRaisingEvents+=+true;
++++++++process.Exited+%2B=+(s,+e)+=>+tcs.TrySetResult(null);
++++++++return+process.HasExited+?+Task.CompletedTask+:+tcs.Task;
++++}++++++++
}|code-block|syntax|javascript|560503|然后，像这样使用它：|560504|public+static+async+Task<int>+ExecAsync(string+command,+string+args)
{
++++ProcessStartInfo+psi+=+new+ProcessStartInfo();
++++psi.FileName+=+command;
++++psi.Arguments+=+args;

++++using+(Process+proc+=+Process.Start(psi))
++++{
++++++++await+proc.WaitForExitAsync();
++++++++return+proc.ExitCode;
++++}
}|560505|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|$]]

Im really worried about disposal of process, what about wait for exit async?, this is my proposal (based on previous):

<pre><code>public static class ProcessExtensions
{
 public static Task WaitForExitAsync(this Process process)
 {
 var tcs = new TaskCompletionSource&lt;object&gt;();
 process.EnableRaisingEvents = true;
 process.Exited += (s, e) =&gt; tcs.TrySetResult(null);
 return process.HasExited ? Task.CompletedTask : tcs.Task;
 } 
}
</code></pre>

Then, use it like this:

<pre><code>public static async Task&lt;int&gt; ExecAsync(string command, string args)
{
 ProcessStartInfo psi = new ProcessStartInfo();
 psi.FileName = command;
 psi.Arguments = args;

 using (Process proc = Process.Start(psi))
 {
 await proc.WaitForExitAsync();
 return proc.ExitCode;
 }
}
</code></pre>

blocks|key|560583|text|我已经创建了一个类来启动一个过程，并且由于各种需求，它在过去几年中不断增长。在使用过程中，我发现了Process类在处理甚至读取ExitCode时的几个问题。所以这都是由我的班级修复的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|560584|这个类有几种可能性，例如读取输出，以管理员或不同的用户身份启动，捕获异常，以及启动所有这些异步的incl。取消。很好的一点是，在执行过程中也可以读取输出。|560585|public+class+ProcessSettings
{
++++public+string+FileName+{+get;+set;+}
++++public+string+Arguments+{+get;+set;+}+=+"";
++++public+string+WorkingDirectory+{+get;+set;+}+=+"";
++++public+string+InputText+{+get;+set;+}+=+null;
++++public+int+Timeout_milliseconds+{+get;+set;+}+=+-1;
++++public+bool+ReadOutput+{+get;+set;+}
++++public+bool+ShowWindow+{+get;+set;+}
++++public+bool+KeepWindowOpen+{+get;+set;+}
++++public+bool+StartAsAdministrator+{+get;+set;+}
++++public+string+StartAsUsername+{+get;+set;+}
++++public+string+StartAsUsername_Password+{+get;+set;+}
++++public+string+StartAsUsername_Domain+{+get;+set;+}
++++public+bool+DontReadExitCode+{+get;+set;+}
++++public+bool+ThrowExceptions+{+get;+set;+}
++++public+CancellationToken+CancellationToken+{+get;+set;+}
}

public+class+ProcessOutputReader+++//+Optional,+to+get+the+output+while+executing+instead+only+as+result+at+the+end
{
++++public+event+TextEventHandler+OutputChanged;
++++public+event+TextEventHandler+OutputErrorChanged;
++++public+void+UpdateOutput(string+text)
++++{
++++++++OutputChanged?.Invoke(this,+new+TextEventArgs(text));
++++}
++++public+void+UpdateOutputError(string+text)
++++{
++++++++OutputErrorChanged?.Invoke(this,+new+TextEventArgs(text));
++++}
++++public+delegate+void+TextEventHandler(object+sender,+TextEventArgs+e);
++++public+class+TextEventArgs+:+EventArgs
++++{
++++++++public+string+Text+{+get;+}
++++++++public+TextEventArgs(string+text)+{+Text+=+text;+}
++++}
}

public+class+ProcessResult
{
++++public+string+Output+{+get;+set;+}
++++public+string+OutputError+{+get;+set;+}
++++public+int+ExitCode+{+get;+set;+}
++++public+bool+WasCancelled+{+get;+set;+}
++++public+bool+WasSuccessful+{+get;+set;+}
}

public+class+ProcessStarter
{
++++public+ProcessResult+Execute(ProcessSettings+settings,+ProcessOutputReader+outputReader+=+null)
++++{
++++++++return+Task.Run(()+=>+ExecuteAsync(settings,+outputReader)).GetAwaiter().GetResult();
++++}

++++public+async+Task<ProcessResult>+ExecuteAsync(ProcessSettings+settings,+ProcessOutputReader+outputReader+=+null)
++++{
++++++++if+(settings.FileName+==+null)+throw+new+ArgumentNullException(nameof(ProcessSettings.FileName));
++++++++if+(settings.Arguments+==+null)+throw+new+ArgumentNullException(nameof(ProcessSettings.Arguments));

++++++++var+cmdSwitches+=+"/Q+"+%2B+(settings.KeepWindowOpen+?+"/K"+:+"/C");

++++++++var+arguments+=+$"{cmdSwitches}+{settings.FileName}+{settings.Arguments}";
++++++++var+startInfo+=+new+ProcessStartInfo("cmd",+arguments)
++++++++{
++++++++++++UseShellExecute+=+false,
++++++++++++RedirectStandardOutput+=+settings.ReadOutput,
++++++++++++RedirectStandardError+=+settings.ReadOutput,
++++++++++++RedirectStandardInput+=+settings.InputText+!=+null,
++++++++++++CreateNoWindow+=+!(settings.ShowWindow+%7C%7C+settings.KeepWindowOpen),
++++++++};
++++++++if+(!string.IsNullOrWhiteSpace(settings.StartAsUsername))
++++++++{
++++++++++++if+(string.IsNullOrWhiteSpace(settings.StartAsUsername_Password))
++++++++++++++++throw+new+ArgumentNullException(nameof(ProcessSettings.StartAsUsername_Password));
++++++++++++if+(string.IsNullOrWhiteSpace(settings.StartAsUsername_Domain))
++++++++++++++++throw+new+ArgumentNullException(nameof(ProcessSettings.StartAsUsername_Domain));
++++++++++++if+(string.IsNullOrWhiteSpace(settings.WorkingDirectory))
++++++++++++++++settings.WorkingDirectory+=+Path.GetPathRoot(Path.GetTempPath());

++++++++++++startInfo.UserName+=+settings.StartAsUsername;
++++++++++++startInfo.PasswordInClearText+=+settings.StartAsUsername_Password;
++++++++++++startInfo.Domain+=+settings.StartAsUsername_Domain;
++++++++}
++++++++var+output+=+new+StringBuilder();
++++++++var+error+=+new+StringBuilder();
++++++++if+(!settings.ReadOutput)
++++++++{
++++++++++++output.AppendLine($"Enable+{nameof(ProcessSettings.ReadOutput)}+to+get+Output");
++++++++}
++++++++if+(settings.StartAsAdministrator)
++++++++{
++++++++++++startInfo.Verb+=+"runas";
++++++++++++startInfo.UseShellExecute+=+true;++//+Verb="runas"+only+possible+with+ShellExecute=true.
++++++++++++startInfo.RedirectStandardOutput+=+startInfo.RedirectStandardError+=+startInfo.RedirectStandardInput+=+false;
++++++++++++output.AppendLine("Output+couldn't+be+read+when+started+as+Administrator");
++++++++}
++++++++if+(!string.IsNullOrWhiteSpace(settings.WorkingDirectory))
++++++++{
++++++++++++startInfo.WorkingDirectory+=+settings.WorkingDirectory;
++++++++}
++++++++var+result+=+new+ProcessResult();
++++++++var+taskCompletionSourceProcess+=+new+TaskCompletionSource<bool>();

++++++++var+process+=+new+Process+{+StartInfo+=+startInfo,+EnableRaisingEvents+=+true+};
++++++++try
++++++++{
++++++++++++process.OutputDataReceived+%2B=+(sender,+e)+=>
++++++++++++{
++++++++++++++++if+(e?.Data+!=+null)
++++++++++++++++{
++++++++++++++++++++output.AppendLine(e.Data);
++++++++++++++++++++outputReader?.UpdateOutput(e.Data);
++++++++++++++++}
++++++++++++};
++++++++++++process.ErrorDataReceived+%2B=+(sender,+e)+=>
++++++++++++{
++++++++++++++++if+(e?.Data+!=+null)
++++++++++++++++{
++++++++++++++++++++error.AppendLine(e.Data);
++++++++++++++++++++outputReader?.UpdateOutputError(e.Data);
++++++++++++++++}
++++++++++++};
++++++++++++process.Exited+%2B=+(sender,+e)+=>
++++++++++++{
++++++++++++++++try+{+(sender+as+Process)?.WaitForExit();+}+catch+(InvalidOperationException)+{+}
++++++++++++++++taskCompletionSourceProcess.TrySetResult(false);
++++++++++++};

++++++++++++var+success+=+false;
++++++++++++try
++++++++++++{
++++++++++++++++process.Start();
++++++++++++++++success+=+true;
++++++++++++}
++++++++++++catch+(System.ComponentModel.Win32Exception+ex)
++++++++++++{
++++++++++++++++if+(ex.NativeErrorCode+==+1223)
++++++++++++++++{
++++++++++++++++++++error.AppendLine("AdminRights+request+Cancelled+by+User!!+"+%2B+ex);
++++++++++++++++++++if+(settings.ThrowExceptions)+taskCompletionSourceProcess.SetException(ex);+else+taskCompletionSourceProcess.TrySetResult(false);
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++error.AppendLine("Win32Exception+thrown:+"+%2B+ex);
++++++++++++++++++++if+(settings.ThrowExceptions)+taskCompletionSourceProcess.SetException(ex);+else+taskCompletionSourceProcess.TrySetResult(false);
++++++++++++++++}
++++++++++++}
++++++++++++catch+(Exception+ex)
++++++++++++{
++++++++++++++++error.AppendLine("Exception+thrown:+"+%2B+ex);
++++++++++++++++if+(settings.ThrowExceptions)+taskCompletionSourceProcess.SetException(ex);+else+taskCompletionSourceProcess.TrySetResult(false);
++++++++++++}
++++++++++++if+(success+&&+startInfo.RedirectStandardOutput)
++++++++++++++++process.BeginOutputReadLine();
++++++++++++if+(success+&&+startInfo.RedirectStandardError)
++++++++++++++++process.BeginErrorReadLine();
++++++++++++if+(success+&&+startInfo.RedirectStandardInput)
++++++++++++{
++++++++++++++++var+writeInputTask+=+Task.Factory.StartNew(()+=>+WriteInputTask());
++++++++++++}

++++++++++++async+void+WriteInputTask()
++++++++++++{
++++++++++++++++var+processRunning+=+true;
++++++++++++++++await+Task.Delay(50).ConfigureAwait(false);
++++++++++++++++try+{+processRunning+=+!process.HasExited;+}+catch+{+}
++++++++++++++++while+(processRunning)
++++++++++++++++{
++++++++++++++++++++if+(settings.InputText+!=+null)
++++++++++++++++++++{
++++++++++++++++++++++++try
++++++++++++++++++++++++{
++++++++++++++++++++++++++++await+process.StandardInput.WriteLineAsync(settings.InputText).ConfigureAwait(false);
++++++++++++++++++++++++++++await+process.StandardInput.FlushAsync().ConfigureAwait(false);
++++++++++++++++++++++++++++settings.InputText+=+null;
++++++++++++++++++++++++}
++++++++++++++++++++++++catch+{+}
++++++++++++++++++++}
++++++++++++++++++++await+Task.Delay(5).ConfigureAwait(false);
++++++++++++++++++++try+{+processRunning+=+!process.HasExited;+}+catch+{+processRunning+=+false;+}
++++++++++++++++}
++++++++++++}

++++++++++++if+(success+&&+settings.CancellationToken+!=+default(CancellationToken))
++++++++++++++++settings.CancellationToken.Register(()+=>+taskCompletionSourceProcess.TrySetResult(true));
++++++++++++if+(success+&&+settings.Timeout_milliseconds+>+0)
++++++++++++++++new+CancellationTokenSource(settings.Timeout_milliseconds).Token.Register(()+=>+taskCompletionSourceProcess.TrySetResult(true));

++++++++++++var+taskProcess+=+taskCompletionSourceProcess.Task;
++++++++++++await+taskProcess.ConfigureAwait(false);
++++++++++++if+(taskProcess.Result+==+true)+//+process+was+cancelled+by+token+or+timeout
++++++++++++{
++++++++++++++++if+(!process.HasExited)
++++++++++++++++{
++++++++++++++++++++result.WasCancelled+=+true;
++++++++++++++++++++error.AppendLine("Process+was+cancelled!");
++++++++++++++++++++try
++++++++++++++++++++{
++++++++++++++++++++++++process.CloseMainWindow();
++++++++++++++++++++++++await+Task.Delay(30).ConfigureAwait(false);
++++++++++++++++++++++++if+(!process.HasExited)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++process.Kill();
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++++++catch+{+}
++++++++++++++++}
++++++++++++}
++++++++++++result.ExitCode+=+-1;
++++++++++++if+(!settings.DontReadExitCode)+++++//+Reason:+sometimes,+like+when+timeout+/t+30+is+started,+reading+the+ExitCode+is+only+possible+if+the+timeout+expired,+even+if+process.Kill+was+called+before.
++++++++++++{
++++++++++++++++try+{+result.ExitCode+=+process.ExitCode;+}
++++++++++++++++catch+{+output.AppendLine("Reading+ExitCode+failed.");+}
++++++++++++}
++++++++++++process.Close();
++++++++}
++++++++finally+{+var+disposeTask+=+Task.Factory.StartNew(()+=>+process.Dispose());+}++++//+start+in+new+Task+because+disposing+sometimes+waits+until+the+process+is+finished,+for+example+while+executing+following+command:+ping+-n+30+-w+1000+127.0.0.1+>+nul
++++++++if+(result.ExitCode+==+-1073741510+&&+!result.WasCancelled)
++++++++{
++++++++++++error.AppendLine($"Process+exited+by+user!");
++++++++}
++++++++result.WasSuccessful+=+!result.WasCancelled+&&+result.ExitCode+==+0;
++++++++result.Output+=+output.ToString();
++++++++result.OutputError+=+error.ToString();
++++++++return+result;
++++}
}|code-block|syntax|javascript|560586|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I have built a class to start a process and it was growing over the last years because of various requirements. During the usage I found out several issues with the Process class with disposing and even reading the ExitCode. So this is all fixed by my class.

The class has several possibilities, for example reading output, start as Admin or different user, catch Exceptions and also start all this asynchronous incl. Cancellation. Nice is that reading output is also possible during execution.

<pre><code>public class ProcessSettings
{
 public string FileName { get; set; }
 public string Arguments { get; set; } = "";
 public string WorkingDirectory { get; set; } = "";
 public string InputText { get; set; } = null;
 public int Timeout_milliseconds { get; set; } = -1;
 public bool ReadOutput { get; set; }
 public bool ShowWindow { get; set; }
 public bool KeepWindowOpen { get; set; }
 public bool StartAsAdministrator { get; set; }
 public string StartAsUsername { get; set; }
 public string StartAsUsername_Password { get; set; }
 public string StartAsUsername_Domain { get; set; }
 public bool DontReadExitCode { get; set; }
 public bool ThrowExceptions { get; set; }
 public CancellationToken CancellationToken { get; set; }
}

public class ProcessOutputReader // Optional, to get the output while executing instead only as result at the end
{
 public event TextEventHandler OutputChanged;
 public event TextEventHandler OutputErrorChanged;
 public void UpdateOutput(string text)
 {
 OutputChanged?.Invoke(this, new TextEventArgs(text));
 }
 public void UpdateOutputError(string text)
 {
 OutputErrorChanged?.Invoke(this, new TextEventArgs(text));
 }
 public delegate void TextEventHandler(object sender, TextEventArgs e);
 public class TextEventArgs : EventArgs
 {
 public string Text { get; }
 public TextEventArgs(string text) { Text = text; }
 }
}

public class ProcessResult
{
 public string Output { get; set; }
 public string OutputError { get; set; }
 public int ExitCode { get; set; }
 public bool WasCancelled { get; set; }
 public bool WasSuccessful { get; set; }
}

public class ProcessStarter
{
 public ProcessResult Execute(ProcessSettings settings, ProcessOutputReader outputReader = null)
 {
 return Task.Run(() =&gt; ExecuteAsync(settings, outputReader)).GetAwaiter().GetResult();
 }

 public async Task&lt;ProcessResult&gt; ExecuteAsync(ProcessSettings settings, ProcessOutputReader outputReader = null)
 {
 if (settings.FileName == null) throw new ArgumentNullException(nameof(ProcessSettings.FileName));
 if (settings.Arguments == null) throw new ArgumentNullException(nameof(ProcessSettings.Arguments));

 var cmdSwitches = "/Q " + (settings.KeepWindowOpen ? "/K" : "/C");

 var arguments = $"{cmdSwitches} {settings.FileName} {settings.Arguments}";
 var startInfo = new ProcessStartInfo("cmd", arguments)
 {
 UseShellExecute = false,
 RedirectStandardOutput = settings.ReadOutput,
 RedirectStandardError = settings.ReadOutput,
 RedirectStandardInput = settings.InputText != null,
 CreateNoWindow = !(settings.ShowWindow || settings.KeepWindowOpen),
 };
 if (!string.IsNullOrWhiteSpace(settings.StartAsUsername))
 {
 if (string.IsNullOrWhiteSpace(settings.StartAsUsername_Password))
 throw new ArgumentNullException(nameof(ProcessSettings.StartAsUsername_Password));
 if (string.IsNullOrWhiteSpace(settings.StartAsUsername_Domain))
 throw new ArgumentNullException(nameof(ProcessSettings.StartAsUsername_Domain));
 if (string.IsNullOrWhiteSpace(settings.WorkingDirectory))
 settings.WorkingDirectory = Path.GetPathRoot(Path.GetTempPath());

 startInfo.UserName = settings.StartAsUsername;
 startInfo.PasswordInClearText = settings.StartAsUsername_Password;
 startInfo.Domain = settings.StartAsUsername_Domain;
 }
 var output = new StringBuilder();
 var error = new StringBuilder();
 if (!settings.ReadOutput)
 {
 output.AppendLine($"Enable {nameof(ProcessSettings.ReadOutput)} to get Output");
 }
 if (settings.StartAsAdministrator)
 {
 startInfo.Verb = "runas";
 startInfo.UseShellExecute = true; // Verb="runas" only possible with ShellExecute=true.
 startInfo.RedirectStandardOutput = startInfo.RedirectStandardError = startInfo.RedirectStandardInput = false;
 output.AppendLine("Output couldn't be read when started as Administrator");
 }
 if (!string.IsNullOrWhiteSpace(settings.WorkingDirectory))
 {
 startInfo.WorkingDirectory = settings.WorkingDirectory;
 }
 var result = new ProcessResult();
 var taskCompletionSourceProcess = new TaskCompletionSource&lt;bool&gt;();

 var process = new Process { StartInfo = startInfo, EnableRaisingEvents = true };
 try
 {
 process.OutputDataReceived += (sender, e) =&gt;
 {
 if (e?.Data != null)
 {
 output.AppendLine(e.Data);
 outputReader?.UpdateOutput(e.Data);
 }
 };
 process.ErrorDataReceived += (sender, e) =&gt;
 {
 if (e?.Data != null)
 {
 error.AppendLine(e.Data);
 outputReader?.UpdateOutputError(e.Data);
 }
 };
 process.Exited += (sender, e) =&gt;
 {
 try { (sender as Process)?.WaitForExit(); } catch (InvalidOperationException) { }
 taskCompletionSourceProcess.TrySetResult(false);
 };

 var success = false;
 try
 {
 process.Start();
 success = true;
 }
 catch (System.ComponentModel.Win32Exception ex)
 {
 if (ex.NativeErrorCode == 1223)
 {
 error.AppendLine("AdminRights request Cancelled by User!! " + ex);
 if (settings.ThrowExceptions) taskCompletionSourceProcess.SetException(ex); else taskCompletionSourceProcess.TrySetResult(false);
 }
 else
 {
 error.AppendLine("Win32Exception thrown: " + ex);
 if (settings.ThrowExceptions) taskCompletionSourceProcess.SetException(ex); else taskCompletionSourceProcess.TrySetResult(false);
 }
 }
 catch (Exception ex)
 {
 error.AppendLine("Exception thrown: " + ex);
 if (settings.ThrowExceptions) taskCompletionSourceProcess.SetException(ex); else taskCompletionSourceProcess.TrySetResult(false);
 }
 if (success &amp;&amp; startInfo.RedirectStandardOutput)
 process.BeginOutputReadLine();
 if (success &amp;&amp; startInfo.RedirectStandardError)
 process.BeginErrorReadLine();
 if (success &amp;&amp; startInfo.RedirectStandardInput)
 {
 var writeInputTask = Task.Factory.StartNew(() =&gt; WriteInputTask());
 }

 async void WriteInputTask()
 {
 var processRunning = true;
 await Task.Delay(50).ConfigureAwait(false);
 try { processRunning = !process.HasExited; } catch { }
 while (processRunning)
 {
 if (settings.InputText != null)
 {
 try
 {
 await process.StandardInput.WriteLineAsync(settings.InputText).ConfigureAwait(false);
 await process.StandardInput.FlushAsync().ConfigureAwait(false);
 settings.InputText = null;
 }
 catch { }
 }
 await Task.Delay(5).ConfigureAwait(false);
 try { processRunning = !process.HasExited; } catch { processRunning = false; }
 }
 }

 if (success &amp;&amp; settings.CancellationToken != default(CancellationToken))
 settings.CancellationToken.Register(() =&gt; taskCompletionSourceProcess.TrySetResult(true));
 if (success &amp;&amp; settings.Timeout_milliseconds &gt; 0)
 new CancellationTokenSource(settings.Timeout_milliseconds).Token.Register(() =&gt; taskCompletionSourceProcess.TrySetResult(true));

 var taskProcess = taskCompletionSourceProcess.Task;
 await taskProcess.ConfigureAwait(false);
 if (taskProcess.Result == true) // process was cancelled by token or timeout
 {
 if (!process.HasExited)
 {
 result.WasCancelled = true;
 error.AppendLine("Process was cancelled!");
 try
 {
 process.CloseMainWindow();
 await Task.Delay(30).ConfigureAwait(false);
 if (!process.HasExited)
 {
 process.Kill();
 }
 }
 catch { }
 }
 }
 result.ExitCode = -1;
 if (!settings.DontReadExitCode) // Reason: sometimes, like when timeout /t 30 is started, reading the ExitCode is only possible if the timeout expired, even if process.Kill was called before.
 {
 try { result.ExitCode = process.ExitCode; }
 catch { output.AppendLine("Reading ExitCode failed."); }
 }
 process.Close();
 }
 finally { var disposeTask = Task.Factory.StartNew(() =&gt; process.Dispose()); } // start in new Task because disposing sometimes waits until the process is finished, for example while executing following command: ping -n 30 -w 1000 127.0.0.1 &gt; nul
 if (result.ExitCode == -1073741510 &amp;&amp; !result.WasCancelled)
 {
 error.AppendLine($"Process exited by user!");
 }
 result.WasSuccessful = !result.WasCancelled &amp;&amp; result.ExitCode == 0;
 result.Output = output.ToString();
 result.OutputError = error.ToString();
 return result;
 }
}
</code></pre>

blocks|key|344709|text|我认为你应该使用的就是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|344710|using+System.Diagnostics;
using+System.Threading;
using+System.Threading.Tasks;

namespace+Extensions
{
++++public+static+class+ProcessExtensions
++++{
++++++++public+static+async+Task<int>+WaitForExitAsync(this+Process+process,+CancellationToken+cancellationToken+=+default)
++++++++{
++++++++++++process+=+process+??+throw+new+ArgumentNullException(nameof(process));
++++++++++++process.EnableRaisingEvents+=+true;

++++++++++++var+completionSource+=+new+TaskCompletionSource<int>();

++++++++++++process.Exited+%2B=+(sender,+args)+=>
++++++++++++{
++++++++++++++++completionSource.TrySetResult(process.ExitCode);
++++++++++++};
++++++++++++if+(process.HasExited)
++++++++++++{
++++++++++++++++return+process.ExitCode;
++++++++++++}

++++++++++++using+var+registration+=+cancellationToken.Register(
++++++++++++++++()+=>+completionSource.TrySetCanceled(cancellationToken));

++++++++++++return+await+completionSource.Task.ConfigureAwait(false);
++++++++}
++++}
}|code-block|syntax|javascript|344711|使用示例：|344712|public+static+async+Task<int>+StartProcessAsync(ProcessStartInfo+info,+CancellationToken+cancellationToken+=+default)
{
++++path+=+path+??+throw+new+ArgumentNullException(nameof(path));
++++if+(!File.Exists(path))
++++{
++++++++throw+new+ArgumentException(@"File+is+not+exists",+nameof(path));
++++}

++++using+var+process+=+Process.Start(info);
++++if+(process+==+null)
++++{
++++++++throw+new+InvalidOperationException("Process+is+null");
++++}

++++try
++++{
++++++++return+await+process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
++++}
++++catch+(OperationCanceledException)
++++{
++++++++process.Kill();

++++++++throw;
++++}
}|344713|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|$]]

I think all you should use is this:

<pre class="lang-cs prettyprint-override"><code>using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace Extensions
{
 public static class ProcessExtensions
 {
 public static async Task&lt;int&gt; WaitForExitAsync(this Process process, CancellationToken cancellationToken = default)
 {
 process = process ?? throw new ArgumentNullException(nameof(process));
 process.EnableRaisingEvents = true;

 var completionSource = new TaskCompletionSource&lt;int&gt;();

 process.Exited += (sender, args) =&gt;
 {
 completionSource.TrySetResult(process.ExitCode);
 };
 if (process.HasExited)
 {
 return process.ExitCode;
 }

 using var registration = cancellationToken.Register(
 () =&gt; completionSource.TrySetCanceled(cancellationToken));

 return await completionSource.Task.ConfigureAwait(false);
 }
 }
}

</code></pre>

Usage example:

<pre class="lang-cs prettyprint-override"><code>public static async Task&lt;int&gt; StartProcessAsync(ProcessStartInfo info, CancellationToken cancellationToken = default)
{
 path = path ?? throw new ArgumentNullException(nameof(path));
 if (!File.Exists(path))
 {
 throw new ArgumentException(@"File is not exists", nameof(path));
 }

 using var process = Process.Start(info);
 if (process == null)
 {
 throw new InvalidOperationException("Process is null");
 }

 try
 {
 return await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false);
 }
 catch (OperationCanceledException)
 {
 process.Kill();

 throw;
 }
}
</code></pre>

blocks|key|560723|text|在.Net+5.0中，有一个官方的内置WaitForExitAsync方法，因此您不必自己实现。此外，Python现在接受IEnumerable<string>形式的参数(类似于Python/Golang等其他编程语言)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|560724|下面是一个示例：|560725|public+static+async+Task+YourMethod()+{
++++var+p+=+Process.Start("bin_name",+new[]{"arg1",+"arg2",+"arg3"});
++++await+p.WaitForExitAsync().ConfigureAwait(false);
++++//+more+code;
}|code-block|syntax|javascript|560726|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.waitforexitasync?view=net-5.0^0|1P|J|J|G|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

In .Net 5.0, there is an official built-in <a href="https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.waitforexitasync?view=net-5.0" rel="noreferrer">WaitForExitAsync</a> method, so you don't have to implement yourself. Also, <a href="https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.process.start?view=net-5.0#System_Diagnostics_Process_Start_System_String_System_Collections_Generic_IEnumerable_System_String__" rel="noreferrer">Start</a> method now accepts arguments as <code>IEnumerable&lt;string&gt;</code> (which is similar to other programming languages like Python/Golang).
Here is an example:
<pre><code>public static async Task YourMethod() {
 var p = Process.Start(&quot;bin_name&quot;, new[]{&quot;arg1&quot;, &quot;arg2&quot;, &quot;arg3&quot;});
 await p.WaitForExitAsync().ConfigureAwait(false);
 // more code;
}
</code></pre>

blocks|key|344865|text|在.NET+5中可以调用WaitForExitAsync，但在.NET框架中不存在该方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|344866|我建议(即使你正在使用.NET+5%2B)+CliWrap库，它提供了开箱即用的异步支持(希望能处理所有的竞态条件)，并使管道和路由输出等工作变得容易。|344867|我最近才发现它，我必须说到目前为止我真的很喜欢它！|344868|愚蠢的例子：|344869|var+cmd+=+Cli.Wrap(@"C:\test\app.exe")
++++.WithArguments("-foo+bar")
++++.WithStandardOutputPipe(PipeTarget.ToFile(@"C:\test\stdOut.txt"))
++++.WithStandardErrorPipe(PipeTarget.ToDelegate(s+=>+Debug.WriteLine(s)));

var+result+=+await+cmd.ExecuteAsync(cancellationToken);
Debug.WriteLine(result.ExitCode);|code-block|syntax|javascript|344870|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/Tyrrrz/CliWrap^0|C|G|0|K|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|H|3|I|5|6|7|15|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|16|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|17|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

In .NET 5 you can call <code>WaitForExitAsync</code>, but in .NET Framework that method doesn't exist.
I would suggest (even if you're using .NET 5+) the <a href="https://github.com/Tyrrrz/CliWrap" rel="nofollow noreferrer">CliWrap</a> library which provides async support out of the box (and hopefully handles all the race conditions) and makes it easy to do things like piping and routing output.
I only recently discovered it and I must say I really like it so far!
Silly example:
<pre><code>var cmd = Cli.Wrap(@&quot;C:\test\app.exe&quot;)
 .WithArguments(&quot;-foo bar&quot;)
 .WithStandardOutputPipe(PipeTarget.ToFile(@&quot;C:\test\stdOut.txt&quot;))
 .WithStandardErrorPipe(PipeTarget.ToDelegate(s =&gt; Debug.WriteLine(s)));

var result = await cmd.ExecuteAsync(cancellationToken);
Debug.WriteLine(result.ExitCode);
</code></pre>

Like the title suggests, is there an equivalent to <code>Process.Start</code> (allows you run another application or batch file) that I can await?

I'm playing with a small console app and this seemed like the perfect place to be using async and await but I can't find any documentation for this scenario.

What I'm thinking is something along these lines:

<pre><code>void async RunCommand()
{
 var result = await Process.RunAsync("command to run");
}
</code></pre>

Is there any async equivalent of Process.Start?

路由

Python

正如标题所暗示的，有没有一个等同于Process.Start (允许您运行另一个应用程序或批处理文件)的工具可以让我等待？我正在玩一个小的控制台应用程序，这里似乎是使用异步和等待的完美位置，但我找不到任何关于这种情况的文档。我的想法是这样的：void async RunCommand(){    var result ...

问是否存在Process.Start的异步等效项？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否存在Process.Start的异步等效项？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否存在Process.Start的异步等效项？
EN