AsyncProcess
About
This library is a very simple wrapper around System.Diagnostics.Process
, allowing for async/await operations.
Rather than creating and starting a Process
, you instead create an AsyncProcess
and await on the running of said process.
Currently the library does not support all operations possible with System.Diagnostics.Process
, but it does allow for the following:
- Running a process and async awaiting for the process to end.
- Capturing of standard output streams.
- Capturing of standard error streams.
- Setting of the
CreateNoWindow
property.
- Setting of launch arguments
- Setting of the current working directory.
- Cancelling of async processes.
All run methods for the AsyncProcess
return an AsyncProcessResult
.
This result contains the state of the result (i.e. did the process complete or did an error occur).
If the process completed successfully, the result will contain the exit code of the process.
If the process failed, an Exception
property will be set to the exception which occurred whilst running the process.
When constructing an AsyncProcess
object you may pass an option cancellation token which will be respected by the async process.
However, the process may not exit immediately. When a cancellation token is set the Kill
method will be executed on the internal
System.Diagnostics.Process
and we will wait until the processes HasExited
property returns true.
Example
Running a process and using the exit code of the process
using (var process = new AsyncProcess(new AsyncProcessStartInfo("ping.exe", "www.github.com")))
{
var result = await process.Run();
Console.WriteLine($"The pinging of github resulted in the exit code: {result.ExitCode}");
}
Running a process and handling an error
using (var process = new AsyncProcess(new AsyncProcessStartInfo("missing-file.exe")))
{
var result = await process.Run();
if (result.Exception != null)
{
throw new Exception($"Failed to run 'missing-file.exe', result: ${result.CompletionState}",
result.Exception);
}
}
Capturing output from a process using callbacks
var startInfo = new AsyncProcessStartInfo("ping.exe", "www.github.com")
{
OnStandardOutputReceived = message =>
{
Console.WriteLine($"Info: {message}");
},
OnStandardErrorReceived = message =>
{
Console.WriteLine($"Error: {message}");
}
};
using (var process = new AsyncProcess(startInfo))
{
var result = await process.Run();
Console.WriteLine($"The pinging of github resulted in the exit code: {result.ExitCode}");
}
Capturing output from a process storing it in the result
var startInfo = new AsyncProcessStartInfo("ping.exe", "www.github.com")
{
CaptureOutputToProcessResult = ProcessOutputCaptureMode.Both
};
using (var process = new AsyncProcess(startInfo))
{
var result = await process.Run();
Console.WriteLine($"The pinging of github resulted in the exit code: {result.ExitCode}");
Console.WriteLine($"Standard Output: {result.StandardOutput}");
Console.WriteLine($"Standard Error: {result.StandardError}");
}
Helper Methods
There are a few helper methods which allow for single line usage of the AsyncProcess class
await AsyncProcess.Run("notepad.exe")
/// <summary>
/// Create a new process, executing the specified file.
/// </summary>
/// <param name="fileName">The file to use when launching the process.</param>
/// <returns>An awaitable task containing the result of the process run.</returns>
public static async Task<AsyncProcessResult> Run(string fileName)
await AsyncProcess.Run("notepad.exe", @"C:\Windows\System32\drivers\etc\hosts")
/// <summary>
/// Create a new process, executing the specified file with the provided launch arguments.
/// </summary>
/// <param name="fileName">The file to use when launching the process.</param>
/// <param name="arguments">The arguments to use when launching the process.</param>
/// <returns>An awaitable task containing the result of the process run.</returns>
public static async Task<AsyncProcessResult> Run(string fileName, string arguments)
await AsyncProcess.Run(new AsyncProcessStartInfo("notepad.exe"))
/// <summary>
/// Create a new process, executing using the provided start info.
/// </summary>
/// <param name="startInfo">The information used when starting the new process.</param>
/// <returns>An awaitable task containing the result of the process run.</returns>
public static async Task<AsyncProcessResult> Run(AsyncProcessStartInfo startInfo)