public static Process CreateForRun([NotNull] string execName, string arguments, [NotNull] RunSettingsBase settings)
{
return(CreateForRun(execName, arguments, settings, out bool _, out bool _));
}
public static Process CreateForRun([NotNull] string execName, string arguments, [NotNull] RunSettingsBase settings, out bool redirectOutput, out bool redirectError)
{
Process process = CreateForRunCore(execName, arguments, settings);
IOnProcessStartAndExit processStartAndExit = settings;
IOnProcessEvents processEvents = settings as IOnProcessEvents;
redirectOutput = settings.RedirectOutput || processEvents?.OnOutput != null;
redirectError = settings.RedirectError || processEvents?.OnError != null;
process.EnableRaisingEvents = settings.RedirectInput || redirectOutput || redirectError || processStartAndExit.OnExit != null;
ProcessStartInfo startInfo = process.StartInfo;
startInfo.RedirectStandardInput = settings.RedirectInput;
startInfo.RedirectStandardOutput = redirectOutput;
startInfo.RedirectStandardError = redirectError;
if (startInfo.RedirectStandardOutput)
{
startInfo.StandardOutputEncoding = EncodingHelper.Default;
}
if (startInfo.RedirectStandardError)
{
startInfo.StandardErrorEncoding = EncodingHelper.Default;
}
if (processEvents != null)
{
if (processEvents.OnOutput != null)
{
process.OutputDataReceived += (_, args) => processEvents.OnOutput(args.Data);
}
if (processEvents.OnError != null)
{
process.ErrorDataReceived += (_, args) => processEvents.OnError(args.Data);
}
}
if (processStartAndExit.OnExit != null)
{
process.Exited += (sender, _) =>
{
Process p = (Process)sender;
DateTime?exitTime = null;
int? exitCode = null;
if (p.IsAssociated())
{
try
{
exitTime = p.ExitTime;
exitCode = p.ExitCode;
}
catch
{
// ignored
}
}
processStartAndExit.OnExit(execName, exitTime, exitCode);
};
}
return(process);
}
public static Process CreateForRun([NotNull] string execName, [NotNull] RunSettingsBase settings)
{
return(CreateForRun(execName, null, settings));
}
public static RunOutput RunAndGetOutput([NotNull] string execName, string arguments, RunSettingsBase settings, WaitHandle awaitableHandle)
{
settings ??= RunSettingsBase.Default;
settings.RedirectOutput = true;
settings.RedirectError = true;
RunOutput output = new RunOutput();
using (Process process = CreateForRun(execName, arguments, settings))
{
bool processReallyExited = false;
process.Exited += (sender, _) =>
{
Process p = (Process)sender;
if (p.IsAssociated())
{
try
{
output.ExitTime = p.ExitTime;
output.ExitCode = p.ExitCode;
}
catch
{
// ignored
}
}
processReallyExited = true;
settings.OnExit?.Invoke(execName, output.ExitTime, output.ExitCode);
};
try
{
bool result = process.Start();
if (!result)
{
return(null);
}
if (!settings.JobHandle.IsInvalidHandle())
{
ProcessJob.AddProcess(settings.JobHandle, process);
}
output.StartTime = process.StartTime;
settings.OnStart?.Invoke(execName, output.StartTime);
AsyncStreamReader outputReader = new AsyncStreamReader(process, process.StandardOutput.BaseStream, data =>
{
if (data == null)
{
return;
}
output.Output.Append(data);
output.OutputBuilder.Append(data);
}, process.StandardOutput.CurrentEncoding);
outputReader.BeginRead();
AsyncStreamReader errorReader = new AsyncStreamReader(process, process.StandardError.BaseStream, data =>
{
if (data == null)
{
return;
}
output.Error.Append(data);
output.OutputBuilder.Append(data);
}, process.StandardOutput.CurrentEncoding);
errorReader.BeginRead();
if (!awaitableHandle.IsAwaitable())
{
process.WaitForExit();
return(output);
}
SafeWaitHandle waitHandle = null;
ManualResetEvent processFinishedEvent = null;
try
{
waitHandle = new SafeWaitHandle(process.Handle, false);
if (!waitHandle.IsAwaitable())
{
return(null);
}
processFinishedEvent = new ManualResetEvent(false)
{
SafeWaitHandle = waitHandle
};
if (!awaitableHandle.IsAwaitable())
{
return(null);
}
WaitHandle[] waitHandles =
{
processFinishedEvent,
awaitableHandle
};
int ndx = waitHandles.WaitAny();
if (ndx != 0)
{
return(null);
}
if (!processReallyExited && process.IsAwaitable())
{
if (!process.WaitForExit(TimeSpanHelper.HALF))
{
ndx = -1;
}
}
process.Die();
return(ndx != 0 ? null : output);
}
finally
{
processFinishedEvent?.Close();
ObjectHelper.Dispose(ref processFinishedEvent);
waitHandle?.Close();
ObjectHelper.Dispose(ref waitHandle);
}
}
catch (Win32Exception e)
{
throw new InvalidOperationException(e.CollectMessages(), e);
}
}
}
public static RunOutput RunAndGetOutput([NotNull] string execName, RunSettingsBase settings, WaitHandle awaitableHandle)
{
return(RunAndGetOutput(execName, null, settings, awaitableHandle));
}
public static RunOutput RunAndGetOutput([NotNull] string execName, string arguments, RunSettingsBase settings, CancellationToken token = default(CancellationToken))
{
token.ThrowIfCancellationRequested();
return(RunAndGetOutput(execName, arguments, settings, token.WaitHandle));
}
public static RunOutput RunAndGetOutput([NotNull] string execName, RunSettingsBase settings, CancellationToken token = default(CancellationToken))
{
return(RunAndGetOutput(execName, null, settings, token));
}
