feat: add ProcessId for CommandResult

Author: WeihanLi

src/WeihanLi.Common/Extensions/ProcessExtension.cs

@@ -93,8 +93,23 @@ public static CommandResult GetResult(this ProcessStartInfo psi)
         using var stdOut = new StringWriter(stdOutStringBuilder);
         var stdErrStringBuilder = new StringBuilder();
         using var stdErr = new StringWriter(stdErrStringBuilder);
-        var exitCode = GetExitCode(psi, stdOut, stdErr);
-        return new CommandResult(exitCode, stdOutStringBuilder.ToString(), stdErrStringBuilder.ToString());
+        var exitCode = -1;
+        int? processId = null;
+        Action<Process> processStartAction = p => processId = p.Id;
+
+        try
+        {
+            using var process = psi.ExecuteProcess(stdOut, stdErr, processStartAction);
+            exitCode = process.ExitCode;
+        }
+        catch (Win32Exception win32Exception)
+        {
+            exitCode = win32Exception.ErrorCode;
+        }
+        return new(exitCode, stdOutStringBuilder.ToString(), stdErrStringBuilder.ToString())
+        {
+            ProcessId = processId
+        };
     }
 
     /// <summary>
@@ -107,16 +122,30 @@ public static async Task<CommandResult> GetResultAsync(this ProcessStartInfo psi
     {
         var stdOutStringBuilder = new StringBuilder();
 #if NETSTANDARD2_1 || NET6_0_OR_GREATER
-        await 
+        await
 #endif
         using var stdOut = new StringWriter(stdOutStringBuilder);
         var stdErrStringBuilder = new StringBuilder();
 #if NETSTANDARD2_1 || NET6_0_OR_GREATER
-        await 
+        await
 #endif
         using var stdErr = new StringWriter(stdErrStringBuilder);
-        var exitCode = await GetExitCodeAsync(psi, stdOut, stdErr, cancellationToken);
-        return new(exitCode, stdOutStringBuilder.ToString(), stdErrStringBuilder.ToString());
+        var exitCode = -1;
+        int? processId = null;
+        Action<Process> processStartAction = p => processId = p.Id;
+        try
+        {
+            using var process = await psi.ExecuteProcessAsync(stdOut, stdErr, processStartAction.WrapTask(), cancellationToken);
+            exitCode = process.ExitCode;
+        }
+        catch (Win32Exception win32Exception)
+        {
+            exitCode = win32Exception.ErrorCode;
+        }
+        return new(exitCode, stdOutStringBuilder.ToString(), stdErrStringBuilder.ToString())
+        {
+            ProcessId = processId
+        };
     }
 
     /// <summary>
@@ -128,11 +157,48 @@ public static async Task<CommandResult> GetResultAsync(this ProcessStartInfo psi
     /// <returns>Process exit code</returns>
     public static int GetExitCode(this ProcessStartInfo psi, TextWriter? stdOut = null,
         TextWriter? stdErr = null)
+    {
+        try
+        {
+            using var process = psi.ExecuteProcess(stdOut, stdErr);
+            return process.ExitCode;
+        }
+        catch (Win32Exception win32Exception)
+        {
+            return win32Exception.ErrorCode;
+        }
+    }
+
+    /// <summary>
+    /// Wait for process exit and get exit code
+    /// </summary>
+    /// <param name="psi">Process is started from this information</param>
+    /// <param name="stdOut">Defaults to Console.Out</param>
+    /// <param name="stdErr">Defaults to Console.Error</param>
+    /// <param name="processStartAction"></param>
+    /// <param name="cancellationToken">cancellationToken</param>
+    /// <returns>Process exit code</returns>
+    public static async Task<int> GetExitCodeAsync(this ProcessStartInfo psi, TextWriter? stdOut = null,
+        TextWriter? stdErr = null, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using var process = await psi.ExecuteProcessAsync(stdOut, stdErr, null, cancellationToken);
+            return process.ExitCode;
+        }
+        catch (Win32Exception win32Exception)
+        {
+            return win32Exception.ErrorCode;
+        }
+    }
+
+    public static Process ExecuteProcess(this ProcessStartInfo psi, TextWriter? stdOut = null,
+        TextWriter? stdErr = null, Action<Process>? processStartAction = null)
     {
         psi.RedirectStandardOutput = stdOut != null;
         psi.RedirectStandardError = stdErr != null;
-        psi.UseShellExecute = false;
-        using var process = new Process();
+
+        var process = new Process();
         process.StartInfo = psi;
         process.OutputDataReceived += (_, e) =>
         {
@@ -145,69 +211,62 @@ public static int GetExitCode(this ProcessStartInfo psi, TextWriter? stdOut = nu
                 stdErr?.WriteLine(e.Data);
         };
 
-        try
-        {
-            process.Start();
-        }
-        catch (Win32Exception win32Exception)
-        {
-            return win32Exception.ErrorCode;
-        }
+        process.Start();
+        processStartAction?.Invoke(process);
 
         process.BeginOutputReadLine();
         process.BeginErrorReadLine();
         process.WaitForExit();
 
-        return process.ExitCode;
+        return process;
     }
 
     /// <summary>
-    /// Wait for process exit and get exit code
+    /// Execute process
     /// </summary>
     /// <param name="psi">Process is started from this information</param>
     /// <param name="stdOut">Defaults to Console.Out</param>
     /// <param name="stdErr">Defaults to Console.Error</param>
+    /// <param name="processStartAction">Action to execute when process start</param>
     /// <param name="cancellationToken">cancellationToken</param>
     /// <returns>Process exit code</returns>
-    public static async Task<int> GetExitCodeAsync(this ProcessStartInfo psi, TextWriter? stdOut = null,
-        TextWriter? stdErr = null, CancellationToken cancellationToken = default)
+    public static async Task<Process> ExecuteProcessAsync(this ProcessStartInfo psi, TextWriter? stdOut = null,
+        TextWriter? stdErr = null, Func<Process, Task>? processStartAction = null, CancellationToken cancellationToken = default)
     {
         psi.RedirectStandardOutput = stdOut != null;
         psi.RedirectStandardError = stdErr != null;
-        psi.UseShellExecute = false;
-        using var process = new Process();
+
+        var process = new Process();
         process.StartInfo = psi;
-        var stdOutComplete = new TaskCompletionSource<object?>();
-        var stdErrComplete = new TaskCompletionSource<object?>();
+        var stdOutComplete = new TaskCompletionSource();
+        var stdErrComplete = new TaskCompletionSource();
         process.OutputDataReceived += (_, e) =>
         {
             if (e.Data != null)
                 stdOut?.WriteLine(e.Data);
             else
-                stdOutComplete.SetResult(null);
+                stdOutComplete.SetResult();
         };
         process.ErrorDataReceived += (_, e) =>
         {
             if (e.Data != null)
                 stdErr?.WriteLine(e.Data);
             else
-                stdErrComplete.SetResult(null);
+                stdErrComplete.SetResult();
         };
-        try
-        {
-            process.Start();
-        }
-        catch (Win32Exception win32Exception)
+
+        process.Start();
+        if (processStartAction is not null)
         {
-            return win32Exception.ErrorCode;
+            await processStartAction.Invoke(process);
         }
 
         process.BeginOutputReadLine();
         process.BeginErrorReadLine();
         using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, ApplicationHelper.ExitToken);
         cts.Token.Register((p) => ((Process)p!).TryKill(), process);
         await Task.WhenAll(process.WaitForExitAsync(cts.Token), stdOutComplete.Task, stdErrComplete.Task);
-        return process.ExitCode;
+        return process;
     }
 
     /// <summary>

src/WeihanLi.Common/Helpers/CommandExecutor.cs

@@ -264,6 +264,7 @@ public sealed class CommandResult(int exitCode, string standardOut, string stand
     public string StandardOut { get; } = standardOut;
     public string StandardError { get; } = standardError;
     public int ExitCode { get; } = exitCode;
+    public int? ProcessId { get; set; }
 
     public CommandResult EnsureSuccessExitCode(int successCode = 0)
     {