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

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

@@ -171,6 +171,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/Resources/Strings.resx

@@ -336,4 +336,7 @@
   <data name="InvalidPerfData" xml:space="preserve">
     <value>Invalid performance counter data with type '{0}'.</value>
   </data>
+  <data name="StartAndForget_RedirectNotSupported" xml:space="preserve">
+    <value>Stream redirection is not supported by StartAndForget. Redirected streams must be drained to avoid deadlocks, which is incompatible with fire-and-forget semantics.</value>
+  </data>
 </root>

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

@@ -20,6 +20,7 @@
     <Compile Include="System\Diagnostics\AsyncStreamReader.cs" />
     <Compile Include="System\Diagnostics\DataReceivedEventArgs.cs" />
     <Compile Include="System\Diagnostics\Process.cs" />
+    <Compile Include="System\Diagnostics\Process.Scenarios.cs" />
     <Compile Include="System\Diagnostics\ProcessExitStatus.cs" />
     <Compile Include="System\Diagnostics\ProcessInfo.cs" />
     <Compile Include="System\Diagnostics\ProcessManager.cs" />

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

@@ -0,0 +1,101 @@
+// 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;
+
+namespace System.Diagnostics
+{
+    public partial class Process
+    {
+        /// <summary>
+        /// Starts the process described by <paramref name="startInfo"/>, captures its process ID,
+        /// 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">
+        /// 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.
+        /// </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,
+        /// disposes the <see cref="Process"/> instance to release all associated resources, and returns the
+        /// process ID. The started process continues to run independently.
+        /// </para>
+        /// <para>
+        /// Calling this method ensures proper resource cleanup on the caller's side: unlike calling
+        /// <see cref="Start(ProcessStartInfo)"/> and discarding the returned object, this method guarantees
+        /// that the underlying operating-system resources held by the <see cref="Process"/> object are
+        /// released promptly.
+        /// </para>
+        /// </remarks>
+        [UnsupportedOSPlatform("ios")]
+        [UnsupportedOSPlatform("tvos")]
+        [SupportedOSPlatform("maccatalyst")]
+        public static int StartAndForget(ProcessStartInfo startInfo)
+        {
+            ArgumentNullException.ThrowIfNull(startInfo);
+
+            if (startInfo.RedirectStandardInput || startInfo.RedirectStandardOutput || startInfo.RedirectStandardError)
+            {
+                throw new InvalidOperationException(SR.StartAndForget_RedirectNotSupported);
+            }
+
+            using Process process = new Process();
+            process.StartInfo = startInfo;
+            process.Start();
+            return process.Id;
+        }
+
+        /// <summary>
+        /// Starts a process with the specified file name and optional arguments, captures its process ID,
+        /// 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,
+        /// disposes the <see cref="Process"/> instance to release all associated resources, and returns the
+        /// process ID. The started process continues to run independently.
+        /// </para>
+        /// <para>
+        /// Calling this method ensures proper resource cleanup on the caller's side: unlike calling
+        /// <see cref="Start(string)"/> and discarding the returned object, this method guarantees that the
+        /// underlying operating-system resources held by the <see cref="Process"/> object are released
+        /// promptly.
+        /// </para>
+        /// </remarks>
+        [UnsupportedOSPlatform("ios")]
+        [UnsupportedOSPlatform("tvos")]
+        [SupportedOSPlatform("maccatalyst")]
+        public static int StartAndForget(string fileName, IList<string>? arguments = null)
+        {
+            ArgumentNullException.ThrowIfNull(fileName);
+
+            ProcessStartInfo startInfo = new ProcessStartInfo(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,75 @@
+// 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 Microsoft.DotNet.RemoteExecutor;
+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)
+        {
+            Process template = CreateProcessLong();
+            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();
+            }
+        }
+
+        [Fact]
+        public void StartAndForget_WithNullArguments_StartsProcess()
+        {
+            // hostname is not available on Android or Azure Linux.
+            // ls is available on every Unix.
+            int pid = Process.StartAndForget(OperatingSystem.IsWindows() ? "hostname" : "ls", 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));
+        }
+    }
+}

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

@@ -36,6 +36,7 @@
     <Compile Include="ProcessThreadTests.cs" />
     <Compile Include="ProcessWaitingTests.cs" />
     <Compile Include="RemotelyInvokable.cs" />
+    <Compile Include="StartAndForget.cs" />
     <Compile Include="AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetPlatformIdentifier)' == 'windows'">