Add Process.StartAndForget APIs for fire-and-forget process launching

src/libraries/System.Diagnostics.Process/ref/System.Diagnostics.Process.cs

@@ -188,6 +188,14 @@ public void Refresh() { }
         [System.CLSCompliantAttribute(false)]
         [System.Runtime.Versioning.SupportedOSPlatformAttribute("windows")]
         public static System.Diagnostics.Process? Start(string fileName, string arguments, string userName, System.Security.SecureString password, string domain) { throw null; }
+        [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+        [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+        [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")] // this needs to come after the ios attribute due to limitations in the platform analyzer
+        public static int StartAndForget(System.Diagnostics.ProcessStartInfo startInfo) { throw null; }
+        [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")]
+        [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")]
+        [System.Runtime.Versioning.SupportedOSPlatformAttribute("maccatalyst")] // this needs to come after the ios attribute due to limitations in the platform analyzer
+        public static int StartAndForget(string fileName, System.Collections.Generic.IList<string>? arguments = null) { throw null; }
         public override string ToString() { throw null; }
         public void WaitForExit() { }
         public bool WaitForExit(int milliseconds) { throw null; }

src/libraries/System.Diagnostics.Process/src/Microsoft/Win32/SafeHandles/SafeProcessHandle.cs

@@ -88,6 +88,15 @@ public SafeProcessHandle(IntPtr existingHandle, bool ownsHandle)
         public static SafeProcessHandle Start(ProcessStartInfo startInfo)
         {
             ArgumentNullException.ThrowIfNull(startInfo);
+
+            return Start(startInfo, fallbackToNull: startInfo.StartDetached);
+        }
+
+        [UnsupportedOSPlatform("ios")]
+        [UnsupportedOSPlatform("tvos")]
+        [SupportedOSPlatform("maccatalyst")]
+        internal static SafeProcessHandle Start(ProcessStartInfo startInfo, bool fallbackToNull)
+        {
             startInfo.ThrowIfInvalid(out bool anyRedirection, out SafeHandle[]? inheritedHandles);
 
             if (anyRedirection)
@@ -110,7 +119,7 @@ public static SafeProcessHandle Start(ProcessStartInfo startInfo)
             SafeFileHandle? childOutputHandle = startInfo.StandardOutputHandle;
             SafeFileHandle? childErrorHandle = startInfo.StandardErrorHandle;
 
-            using SafeFileHandle? nullDeviceHandle = startInfo.StartDetached
+            using SafeFileHandle? nullDeviceHandle = fallbackToNull
                 && (childInputHandle is null || childOutputHandle is null || childErrorHandle is null)
                 ? File.OpenNullHandle()
                 : null;

src/libraries/System.Diagnostics.Process/src/Resources/Strings.resx

@@ -223,7 +223,7 @@
     <value>The KillOnParentExit property cannot be used with UseShellExecute.</value>
   </data>
   <data name="CantSetRedirectForSafeProcessHandleStart" xml:space="preserve">
-    <value>The RedirectStandardInput, RedirectStandardOutput, and RedirectStandardError properties cannot be used by SafeProcessHandle.Start. Use the StandardInputHandle, StandardOutputHandle, and StandardErrorHandle properties.</value>
+    <value>The RedirectStandardInput, RedirectStandardOutput, and RedirectStandardError properties cannot be used by SafeProcessHandle.Start or Process.StartAndForget. Use the StandardInputHandle, StandardOutputHandle, and StandardErrorHandle properties.</value>
   </data>
   <data name="StartDetachedNotCompatible" xml:space="preserve">
     <value>The StartDetached property cannot be used with UseShellExecute set to true.</value>
@@ -363,4 +363,7 @@
   <data name="InheritedHandles_MustNotContainDuplicates" xml:space="preserve">
     <value>InheritedHandles must not contain duplicates.</value>
   </data>
+  <data name="StartAndForget_UseShellExecuteNotSupported" xml:space="preserve">
+    <value>UseShellExecute is not supported by StartAndForget. On Windows, shell execution may not create a new process, which would make it impossible to return a valid process ID.</value>
+  </data>
 </root>

src/libraries/System.Diagnostics.Process/src/System.Diagnostics.Process.csproj

@@ -21,6 +21,7 @@
     <Compile Include="System\Diagnostics\DataReceivedEventArgs.cs" />
     <Compile Include="System\Diagnostics\Process.cs" />
     <Compile Include="System\Diagnostics\Process.Multiplexing.cs" />
+    <Compile Include="System\Diagnostics\Process.Scenarios.cs" />
     <Compile Include="System\Diagnostics\ProcessExitStatus.cs" />
     <Compile Include="System\Diagnostics\ProcessInfo.cs" />
     <Compile Include="System\Diagnostics\ProcessModule.cs" />

src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Scenarios.cs

@@ -0,0 +1,99 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Runtime.Versioning;
+using Microsoft.Win32.SafeHandles;
+
+namespace System.Diagnostics
+{
+    public partial class Process
+    {
+        /// <summary>
+        /// Starts the process described by <paramref name="startInfo"/>, releases all associated resources,
+        /// and returns the process ID.
+        /// </summary>
+        /// <param name="startInfo">The <see cref="ProcessStartInfo"/> that contains the information used to start the process.</param>
+        /// <returns>The process ID of the started process.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="startInfo"/> is <see langword="null"/>.</exception>
+        /// <exception cref="InvalidOperationException">
+        /// <para>One or more of <see cref="ProcessStartInfo.RedirectStandardInput"/>,
+        /// <see cref="ProcessStartInfo.RedirectStandardOutput"/>, or
+        /// <see cref="ProcessStartInfo.RedirectStandardError"/> is set to <see langword="true"/>.
+        /// Stream redirection is not supported in fire-and-forget scenarios because redirected streams
+        /// must be drained to avoid deadlocks.</para>
+        /// <para>-or-</para>
+        /// <para><see cref="ProcessStartInfo.UseShellExecute"/> is set to <see langword="true"/>.
+        /// Shell execution is not supported in fire-and-forget scenarios because on Windows it may not
+        /// create a new process, making it impossible to return a valid process ID.</para>
+        /// </exception>
+        /// <remarks>
+        /// <para>
+        /// When a standard handle (<see cref="ProcessStartInfo.StandardInputHandle"/>,
+        /// <see cref="ProcessStartInfo.StandardOutputHandle"/>, or <see cref="ProcessStartInfo.StandardErrorHandle"/>)
+        /// is not provided, it is redirected to the null file by default.
+        /// </para>
+        /// <para>
+        /// This method is designed for fire-and-forget scenarios where the caller wants to launch a process
+        /// and does not need to interact with it further. It starts the process, releases all associated
+        /// resources, and returns the process ID. The started process continues to run independently.
+        /// </para>
+        /// </remarks>
+        [UnsupportedOSPlatform("ios")]
+        [UnsupportedOSPlatform("tvos")]
+        [SupportedOSPlatform("maccatalyst")]
+        public static int StartAndForget(ProcessStartInfo startInfo)
+        {
+            ArgumentNullException.ThrowIfNull(startInfo);
+
+            if (startInfo.UseShellExecute)
+            {
+                throw new InvalidOperationException(SR.StartAndForget_UseShellExecuteNotSupported);
+            }
+
+            using SafeProcessHandle processHandle = SafeProcessHandle.Start(startInfo, fallbackToNull: true);
+            return processHandle.ProcessId;
+        }
+
+        /// <summary>
+        /// Starts a process with the specified file name and optional arguments, releases all associated resources,
+        /// and returns the process ID.
+        /// </summary>
+        /// <param name="fileName">The name of the application or document to start.</param>
+        /// <param name="arguments">
+        /// The command-line arguments to pass to the process. Pass <see langword="null"/> or an empty list
+        /// to start the process without additional arguments.
+        /// </param>
+        /// <returns>The process ID of the started process.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="fileName"/> is <see langword="null"/>.</exception>
+        /// <remarks>
+        /// <para>
+        /// This method is designed for fire-and-forget scenarios where the caller wants to launch a process
+        /// and does not need to interact with it further. It starts the process, captures its process ID,
+        /// releases all associated resources, and returns the process ID. The started process continues to
+        /// run independently.
+        /// </para>
+        /// <para>
+        /// Standard handles are redirected to the null file by default.
+        /// </para>
+        /// </remarks>
+        [UnsupportedOSPlatform("ios")]
+        [UnsupportedOSPlatform("tvos")]
+        [SupportedOSPlatform("maccatalyst")]
+        public static int StartAndForget(string fileName, IList<string>? arguments = null)
+        {
+            ArgumentNullException.ThrowIfNull(fileName);
+
+            ProcessStartInfo startInfo = new(fileName);
+            if (arguments is not null)
+            {
+                foreach (string argument in arguments)
+                {
+                    startInfo.ArgumentList.Add(argument);
+                }
+            }
+
+            return StartAndForget(startInfo);
+        }
+    }
+}

src/libraries/System.Diagnostics.Process/tests/StartAndForget.cs

@@ -0,0 +1,114 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO;
+using Microsoft.DotNet.RemoteExecutor;
+using Microsoft.Win32.SafeHandles;
+using Xunit;
+
+namespace System.Diagnostics.Tests
+{
+    public class StartAndForgetTests : ProcessTestBase
+    {
+        [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void StartAndForget_StartsProcessAndReturnsValidPid(bool useProcessStartInfo)
+        {
+            using Process template = CreateSleepProcess((int)TimeSpan.FromHours(1).TotalMilliseconds);
+            int pid = useProcessStartInfo
+                ? Process.StartAndForget(template.StartInfo)
+                : Process.StartAndForget(template.StartInfo.FileName, template.StartInfo.ArgumentList);
+
+            Assert.True(pid > 0);
+
+            using Process launched = Process.GetProcessById(pid);
+            try
+            {
+                Assert.False(launched.HasExited);
+            }
+            finally
+            {
+                launched.Kill();
+                launched.WaitForExit();
+            }
+        }
+
+        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        public void StartAndForget_WithStandardOutputHandle_CapturesOutput()
+        {
+            using Process template = CreateProcess(static () =>
+            {
+                Console.Write("hello");
+                return RemoteExecutor.SuccessExitCode;
+            });
+
+            SafeFileHandle.CreateAnonymousPipe(out SafeFileHandle outputReadPipe, out SafeFileHandle outputWritePipe);
+
+            using (outputReadPipe)
+            using (outputWritePipe)
+            {
+                template.StartInfo.StandardOutputHandle = outputWritePipe;
+
+                int pid = Process.StartAndForget(template.StartInfo);
+                Assert.True(pid > 0);
+
+                outputWritePipe.Close(); // close the parent copy of child handle
+
+                using StreamReader streamReader = new(new FileStream(outputReadPipe, FileAccess.Read, bufferSize: 1, outputReadPipe.IsAsync));
+                Assert.Equal("hello", streamReader.ReadToEnd());
+            }
+        }
+
+        // This test does not use RemoteExecutor, but it's a simple way to filter to OSes that support Process.Start.
+        [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        public void StartAndForget_WithNullArguments_StartsProcess()
+        {
+            // cmd is available on every Windows, including Nano. When run with no parameters, it displays the Windows version/copyright banner.
+            // true is available on every Unix. When invoked with no arguments, it does nothing and exits successfully.
+            int pid = Process.StartAndForget(OperatingSystem.IsWindows() ? "cmd.exe" : "true", null);
+
+            Assert.True(pid > 0);
+        }
+
+        [Fact]
+        public void StartAndForget_WithStartInfo_NullStartInfo_ThrowsArgumentNullException()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("startInfo", () => Process.StartAndForget((ProcessStartInfo)null!));
+        }
+
+        [Fact]
+        public void StartAndForget_WithFileName_NullFileName_ThrowsArgumentNullException()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("fileName", () => Process.StartAndForget((string)null!));
+        }
+
+        [Theory]
+        [InlineData(true, false, false)]
+        [InlineData(false, true, false)]
+        [InlineData(false, false, true)]
+        public void StartAndForget_WithRedirectedStreams_ThrowsInvalidOperationException(
+            bool redirectInput, bool redirectOutput, bool redirectError)
+        {
+            ProcessStartInfo startInfo = new("someprocess")
+            {
+                RedirectStandardInput = redirectInput,
+                RedirectStandardOutput = redirectOutput,
+                RedirectStandardError = redirectError,
+            };
+
+            Assert.Throws<InvalidOperationException>(() => Process.StartAndForget(startInfo));
+        }
+
+        [Fact]
+        public void StartAndForget_WithUseShellExecute_ThrowsInvalidOperationException()
+        {
+            ProcessStartInfo startInfo = new("someprocess")
+            {
+                UseShellExecute = true,
+            };
+
+            Assert.Throws<InvalidOperationException>(() => Process.StartAndForget(startInfo));
+        }
+    }
+}

src/libraries/System.Diagnostics.Process/tests/System.Diagnostics.Process.Tests.csproj

@@ -38,6 +38,7 @@
     <Compile Include="ProcessThreadTests.cs" />
     <Compile Include="ProcessWaitingTests.cs" />
     <Compile Include="RemotelyInvokable.cs" />
+    <Compile Include="StartAndForget.cs" />
     <Compile Include="AssemblyInfo.cs" />
     <Compile Include="SafeProcessHandleTests.cs" />
     <Compile Include="KillOnParentExitTests.cs" />