Rename StandardInput/Output/Error to StandardInputHandle/OutputHandle/ErrorHandle, fix docs, add handle validation

Co-authored-by: adamsitnik <6011991+adamsitnik@users.noreply.github.com>
Agent-Logs-Url: https://github.com/dotnet/runtime/sessions/7c3e65ca-2e62-4821-b8d2-0bc9bde12049

Author: Copilot

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

@@ -253,9 +253,9 @@ public ProcessStartInfo(string fileName, System.Collections.Generic.IEnumerable<
         public bool RedirectStandardInput { get { throw null; } set { } }
         public bool RedirectStandardOutput { get { throw null; } set { } }
         public System.Text.Encoding? StandardErrorEncoding { get { throw null; } set { } }
-        public Microsoft.Win32.SafeHandles.SafeFileHandle? StandardError { get { throw null; } set { } }
-        public Microsoft.Win32.SafeHandles.SafeFileHandle? StandardInput { get { throw null; } set { } }
-        public Microsoft.Win32.SafeHandles.SafeFileHandle? StandardOutput { get { throw null; } set { } }
+        public Microsoft.Win32.SafeHandles.SafeFileHandle? StandardErrorHandle { get { throw null; } set { } }
+        public Microsoft.Win32.SafeHandles.SafeFileHandle? StandardInputHandle { get { throw null; } set { } }
+        public Microsoft.Win32.SafeHandles.SafeFileHandle? StandardOutputHandle { get { throw null; } set { } }
         public bool LeaveHandlesOpen { get { throw null; } set { } }
         public System.Text.Encoding? StandardInputEncoding { get { throw null; } set { } }
         public System.Text.Encoding? StandardOutputEncoding { get { throw null; } set { } }

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

@@ -210,8 +210,11 @@
   <data name="CantRedirectStreams" xml:space="preserve">
     <value>The Process object must have the UseShellExecute property set to false in order to redirect IO streams.</value>
   </data>
+  <data name="Arg_InvalidHandle" xml:space="preserve">
+    <value>Invalid handle.</value>
+  </data>
   <data name="CantSetHandleAndRedirect" xml:space="preserve">
-    <value>The StandardInput, StandardOutput, and StandardError handle properties cannot be used together with RedirectStandardInput, RedirectStandardOutput, and RedirectStandardError.</value>
+    <value>The StandardInputHandle, StandardOutputHandle, and StandardErrorHandle properties cannot be used together with RedirectStandardInput, RedirectStandardOutput, and RedirectStandardError.</value>
   </data>
   <data name="DirectoryNotValidAsInput" xml:space="preserve">
     <value>The FileName property should not be a directory unless UseShellExecute is set.</value>

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

@@ -1280,26 +1280,30 @@ public bool Start()
             }
 
             bool anyRedirection = startInfo.RedirectStandardInput || startInfo.RedirectStandardOutput || startInfo.RedirectStandardError;
-            bool anyHandle = startInfo.StandardInput is not null || startInfo.StandardOutput is not null || startInfo.StandardError is not null;
+            bool anyHandle = startInfo.StandardInputHandle is not null || startInfo.StandardOutputHandle is not null || startInfo.StandardErrorHandle is not null;
             if (startInfo.UseShellExecute && (anyRedirection || anyHandle))
             {
                 throw new InvalidOperationException(SR.CantRedirectStreams);
             }
 
             if (anyHandle)
             {
-                if (startInfo.StandardInput is not null && startInfo.RedirectStandardInput)
+                if (startInfo.StandardInputHandle is not null && startInfo.RedirectStandardInput)
                 {
                     throw new InvalidOperationException(SR.CantSetHandleAndRedirect);
                 }
-                if (startInfo.StandardOutput is not null && startInfo.RedirectStandardOutput)
+                if (startInfo.StandardOutputHandle is not null && startInfo.RedirectStandardOutput)
                 {
                     throw new InvalidOperationException(SR.CantSetHandleAndRedirect);
                 }
-                if (startInfo.StandardError is not null && startInfo.RedirectStandardError)
+                if (startInfo.StandardErrorHandle is not null && startInfo.RedirectStandardError)
                 {
                     throw new InvalidOperationException(SR.CantSetHandleAndRedirect);
                 }
+
+                ValidateHandle(startInfo.StandardInputHandle, nameof(startInfo.StandardInputHandle));
+                ValidateHandle(startInfo.StandardOutputHandle, nameof(startInfo.StandardOutputHandle));
+                ValidateHandle(startInfo.StandardErrorHandle, nameof(startInfo.StandardErrorHandle));
             }
 
             //Cannot start a new process and store its handle if the object has been disposed, since finalization has been suppressed.
@@ -1334,9 +1338,9 @@ public bool Start()
 
                     try
                     {
-                        if (startInfo.StandardInput is not null)
+                        if (startInfo.StandardInputHandle is not null)
                         {
-                            childInputPipeHandle = startInfo.StandardInput;
+                            childInputPipeHandle = startInfo.StandardInputHandle;
                         }
                         else if (startInfo.RedirectStandardInput)
                         {
@@ -1347,9 +1351,9 @@ public bool Start()
                             childInputPipeHandle = Console.OpenStandardInputHandle();
                         }
 
-                        if (startInfo.StandardOutput is not null)
+                        if (startInfo.StandardOutputHandle is not null)
                         {
-                            childOutputPipeHandle = startInfo.StandardOutput;
+                            childOutputPipeHandle = startInfo.StandardOutputHandle;
                         }
                         else if (startInfo.RedirectStandardOutput)
                         {
@@ -1360,9 +1364,9 @@ public bool Start()
                             childOutputPipeHandle = Console.OpenStandardOutputHandle();
                         }
 
-                        if (startInfo.StandardError is not null)
+                        if (startInfo.StandardErrorHandle is not null)
                         {
-                            childErrorPipeHandle = startInfo.StandardError;
+                            childErrorPipeHandle = startInfo.StandardErrorHandle;
                         }
                         else if (startInfo.RedirectStandardError)
                         {
@@ -1401,17 +1405,17 @@ public bool Start()
                 // process will not receive EOF when the child process closes its handles.
                 // It's OK to do it for handles returned by Console.OpenStandard*Handle APIs,
                 // because these handles are not owned and won't be closed by Dispose.
-                // When LeaveHandlesOpen is true, we must NOT close handles that were passed in
-                // by the caller via StartInfo.StandardInput/Output/Error.
-                if (startInfo.StandardInput is null || !startInfo.LeaveHandlesOpen)
+                // When LeaveHandlesOpen is true, we must NOT dispose handles that were passed in
+                // by the caller via StartInfo.StandardInputHandle/OutputHandle/ErrorHandle.
+                if (startInfo.StandardInputHandle is null || !startInfo.LeaveHandlesOpen)
                 {
                     childInputPipeHandle?.Dispose();
                 }
-                if (startInfo.StandardOutput is null || !startInfo.LeaveHandlesOpen)
+                if (startInfo.StandardOutputHandle is null || !startInfo.LeaveHandlesOpen)
                 {
                     childOutputPipeHandle?.Dispose();
                 }
-                if (startInfo.StandardError is null || !startInfo.LeaveHandlesOpen)
+                if (startInfo.StandardErrorHandle is null || !startInfo.LeaveHandlesOpen)
                 {
                     childErrorPipeHandle?.Dispose();
                 }
@@ -1439,6 +1443,18 @@ public bool Start()
             return true;
         }
 
+        private static void ValidateHandle(SafeFileHandle? handle, string paramName)
+        {
+            if (handle is not null)
+            {
+                ObjectDisposedException.ThrowIf(handle.IsClosed, paramName);
+                if (handle.IsInvalid)
+                {
+                    throw new ArgumentException(SR.Arg_InvalidHandle, paramName);
+                }
+            }
+        }
+
         /// <devdoc>
         ///    <para>
         ///       Starts a process resource by specifying the name of a

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

@@ -124,14 +124,15 @@ public string Arguments
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The handle does not need to be inheritable; the runtime will make it inheritable as needed.
+        /// The handle does not need to be inheritable; the runtime will duplicate it as inheritable.
         /// Use <see cref="SafeFileHandle.CreateAnonymousPipe"/> to create a pair of connected pipe handles,
         /// <see cref="IO.File.OpenHandle"/> to open a file handle,
-        /// <see cref="IO.File.OpenNullHandle"/> to discard input,
-        /// or <see cref="Console.OpenStandardInputHandle"/> to inherit the parent's standard input.
+        /// <see cref="IO.File.OpenNullHandle"/> to provide an empty input,
+        /// or <see cref="Console.OpenStandardInputHandle"/> to inherit the parent's standard input
+        /// (the default behavior when this property is <see langword="null"/>).
         /// </para>
         /// <para>
-        /// By default, <see cref="Process.Start()"/> will close this handle after starting the child process.
+        /// By default, <see cref="Process.Start()"/> will dispose this handle after starting the child process.
         /// Set <see cref="LeaveHandlesOpen"/> to <see langword="true"/> to keep the handle open.
         /// </para>
         /// <para>
@@ -140,22 +141,23 @@ public string Arguments
         /// </para>
         /// </remarks>
         /// <value>A <see cref="SafeFileHandle"/> to use as the standard input handle of the child process, or <see langword="null"/> to use the default behavior.</value>
-        public SafeFileHandle? StandardInput { get; set; }
+        public SafeFileHandle? StandardInputHandle { get; set; }
 
         /// <summary>
         /// Gets or sets a <see cref="SafeFileHandle"/> that will be used as the standard output of the child process.
         /// When set, the handle is passed directly to the child process and <see cref="RedirectStandardOutput"/> must be <see langword="false"/>.
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The handle does not need to be inheritable; the runtime will make it inheritable as needed.
+        /// The handle does not need to be inheritable; the runtime will duplicate it as inheritable.
         /// Use <see cref="SafeFileHandle.CreateAnonymousPipe"/> to create a pair of connected pipe handles,
         /// <see cref="IO.File.OpenHandle"/> to open a file handle,
         /// <see cref="IO.File.OpenNullHandle"/> to discard output,
-        /// or <see cref="Console.OpenStandardOutputHandle"/> to inherit the parent's standard output.
+        /// or <see cref="Console.OpenStandardOutputHandle"/> to inherit the parent's standard output
+        /// (the default behavior when this property is <see langword="null"/>).
         /// </para>
         /// <para>
-        /// By default, <see cref="Process.Start()"/> will close this handle after starting the child process.
+        /// By default, <see cref="Process.Start()"/> will dispose this handle after starting the child process.
         /// Set <see cref="LeaveHandlesOpen"/> to <see langword="true"/> to keep the handle open.
         /// </para>
         /// <para>
@@ -164,22 +166,23 @@ public string Arguments
         /// </para>
         /// </remarks>
         /// <value>A <see cref="SafeFileHandle"/> to use as the standard output handle of the child process, or <see langword="null"/> to use the default behavior.</value>
-        public SafeFileHandle? StandardOutput { get; set; }
+        public SafeFileHandle? StandardOutputHandle { get; set; }
 
         /// <summary>
         /// Gets or sets a <see cref="SafeFileHandle"/> that will be used as the standard error of the child process.
         /// When set, the handle is passed directly to the child process and <see cref="RedirectStandardError"/> must be <see langword="false"/>.
         /// </summary>
         /// <remarks>
         /// <para>
-        /// The handle does not need to be inheritable; the runtime will make it inheritable as needed.
+        /// The handle does not need to be inheritable; the runtime will duplicate it as inheritable.
         /// Use <see cref="SafeFileHandle.CreateAnonymousPipe"/> to create a pair of connected pipe handles,
         /// <see cref="IO.File.OpenHandle"/> to open a file handle,
         /// <see cref="IO.File.OpenNullHandle"/> to discard error output,
-        /// or <see cref="Console.OpenStandardErrorHandle"/> to inherit the parent's standard error.
+        /// or <see cref="Console.OpenStandardErrorHandle"/> to inherit the parent's standard error
+        /// (the default behavior when this property is <see langword="null"/>).
         /// </para>
         /// <para>
-        /// By default, <see cref="Process.Start()"/> will close this handle after starting the child process.
+        /// By default, <see cref="Process.Start()"/> will dispose this handle after starting the child process.
         /// Set <see cref="LeaveHandlesOpen"/> to <see langword="true"/> to keep the handle open.
         /// </para>
         /// <para>
@@ -188,17 +191,17 @@ public string Arguments
         /// </para>
         /// </remarks>
         /// <value>A <see cref="SafeFileHandle"/> to use as the standard error handle of the child process, or <see langword="null"/> to use the default behavior.</value>
-        public SafeFileHandle? StandardError { get; set; }
+        public SafeFileHandle? StandardErrorHandle { get; set; }
 
         /// <summary>
-        /// Gets or sets a value indicating whether the <see cref="StandardInput"/>, <see cref="StandardOutput"/>,
-        /// and <see cref="StandardError"/> handles should be left open after the process is started.
+        /// Gets or sets a value indicating whether the <see cref="StandardInputHandle"/>, <see cref="StandardOutputHandle"/>,
+        /// and <see cref="StandardErrorHandle"/> handles should be left open after the process is started.
         /// </summary>
         /// <remarks>
-        /// When <see langword="false"/> (the default), the handles are closed by <see cref="Process.Start()"/>
-        /// after starting the child process. When <see langword="true"/>, the caller is responsible for closing the handles.
+        /// When <see langword="false"/> (the default), the handles are disposed by <see cref="Process.Start()"/>
+        /// after starting the child process. When <see langword="true"/>, the caller is responsible for disposing the handles.
         /// </remarks>
-        /// <value><see langword="true"/> to leave the handles open; <see langword="false"/> to close them after the process starts. The default is <see langword="false"/>.</value>
+        /// <value><see langword="true"/> to leave the handles open; <see langword="false"/> to dispose them after the process starts. The default is <see langword="false"/>.</value>
         public bool LeaveHandlesOpen { get; set; }
 
         public Encoding? StandardInputEncoding { get; set; }