Issue 55685 processname optimisation (#59672)

Co-authored-by: Adam Sitnik <[email protected]>

Author: SteveDunn

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.GetProcessName.cs

@@ -0,0 +1,74 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Buffers;
+using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
+
+internal static partial class Interop
+{
+    internal static partial class Kernel32
+    {
+        [DllImport(Libraries.Kernel32, CharSet = CharSet.Unicode, EntryPoint = "QueryFullProcessImageNameW", ExactSpelling = true, SetLastError = true)]
+        private static unsafe extern bool QueryFullProcessImageName(
+            SafeHandle hProcess,
+            uint dwFlags,
+            char* lpBuffer,
+            ref uint lpdwSize);
+
+        internal static unsafe string? GetProcessName(uint processId)
+        {
+            using (SafeProcessHandle handle = OpenProcess(Advapi32.ProcessOptions.PROCESS_QUERY_LIMITED_INFORMATION, false, (int)processId))
+            {
+                if (handle.IsInvalid) // OpenProcess can fail
+                {
+                    return null;
+                }
+
+                const int StartLength =
+#if DEBUG
+                    1; // in debug, validate ArrayPool growth
+#else
+                    Interop.Kernel32.MAX_PATH;
+#endif
+
+                Span<char> buffer = stackalloc char[StartLength + 1];
+                char[]? rentedArray = null;
+
+                try
+                {
+                    while (true)
+                    {
+                        uint length = (uint)buffer.Length;
+                        fixed (char* pinnedBuffer = &MemoryMarshal.GetReference(buffer))
+                        {
+                            if (QueryFullProcessImageName(handle, 0, pinnedBuffer, ref length))
+                            {
+                                return buffer.Slice(0, (int)length).ToString();
+                            }
+                            else if (Marshal.GetLastWin32Error() != Errors.ERROR_INSUFFICIENT_BUFFER)
+                            {
+                                return null;
+                            }
+                        }
+
+                        char[]? toReturn = rentedArray;
+                        buffer = rentedArray = ArrayPool<char>.Shared.Rent(buffer.Length * 2);
+                        if (toReturn is not null)
+                        {
+                            ArrayPool<char>.Shared.Return(toReturn);
+                        }
+                    }
+                }
+                finally
+                {
+                    if (rentedArray is not null)
+                    {
+                        ArrayPool<char>.Shared.Return(rentedArray);
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -159,6 +159,8 @@
              Link="Common\Interop\Windows\Advapi32\Interop.AdjustTokenPrivileges.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetComputerName.cs"
              Link="Common\Interop\Windows\Kernel32\Interop.GetComputerName.cs" />
+    <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetProcessName.cs"
+             Link="Common\Interop\Windows\Kernel32\Interop.GetProcessName.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetConsoleCP.cs"
              Link="Common\Interop\Windows\Kernel32\Interop.GetConsoleCP.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.GetConsoleOutputCP.cs"

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

@@ -1113,5 +1113,15 @@ private static int OnSigChild(int reapAll, int configureConsole)
                 s_processStartLock.ExitWriteLock();
             }
         }
+
+        /// <summary>Gets the friendly name of the process.</summary>
+        public string ProcessName
+        {
+            get
+            {
+                EnsureState(State.HaveProcessInfo);
+                return _processInfo!.ProcessName;
+            }
+        }
     }
 }

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

@@ -83,5 +83,15 @@ private string GetPathToOpenFile()
         }
 
         private int ParentProcessId => throw new PlatformNotSupportedException();
+
+        /// <summary>Gets the friendly name of the process.</summary>
+        public string ProcessName
+        {
+            get
+            {
+                EnsureState(State.HaveProcessInfo);
+                return _processInfo!.ProcessName;
+            }
+        }
     }
 }

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

@@ -17,6 +17,8 @@ public partial class Process : IDisposable
     {
         private static readonly object s_createProcessLock = new object();
 
+        private string? _processName;
+
         /// <summary>
         /// Creates an array of <see cref="Process"/> components that are associated with process resources on a
         /// remote computer. These process resources share the specified process name.
@@ -125,6 +127,7 @@ private void RefreshCore()
             _haveMainWindow = false;
             _mainWindowTitle = null;
             _haveResponding = false;
+            _processName = null;
         }
 
         /// <summary>Additional logic invoked when the Process is closed.</summary>
@@ -887,5 +890,35 @@ private static string GetEnvironmentVariablesBlock(IDictionary<string, string> s
         }
 
         private static string GetErrorMessage(int error) => Interop.Kernel32.GetMessage(error);
+
+        /// <summary>Gets the friendly name of the process.</summary>
+        public string ProcessName
+        {
+            get
+            {
+                if (_processName == null)
+                {
+                    EnsureState(State.HaveNonExitedId);
+                    // If we already have the name via a populated ProcessInfo
+                    // then use that one.
+                    if (_processInfo?.ProcessName != null)
+                    {
+                        _processName = _processInfo!.ProcessName;
+                    }
+                    else
+                    {
+                        // If we don't have a populated ProcessInfo, then get and cache the process name.
+                        _processName = ProcessManager.GetProcessName(_processId, _machineName);
+
+                        if (_processName == null)
+                        {
+                            throw new InvalidOperationException(SR.NoProcessInfo);
+                        }
+                    }
+                }
+
+                return _processName;
+            }
+        }
     }
 }

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

@@ -505,21 +505,6 @@ public int PrivateMemorySize
             }
         }
 
-        /// <devdoc>
-        ///    <para>
-        ///       Gets
-        ///       the friendly name of the process.
-        ///    </para>
-        /// </devdoc>
-        public string ProcessName
-        {
-            get
-            {
-                EnsureState(State.HaveProcessInfo);
-                return _processInfo!.ProcessName;
-            }
-        }
-
         /// <devdoc>
         ///    <para>
         ///       Gets

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

@@ -85,6 +85,39 @@ public static ProcessInfo[] GetProcessInfos(string machineName)
             return null;
         }
 
+        /// <summary>Gets the process name for the specified process ID on the specified machine.</summary>
+        /// <param name="processId">The process ID.</param>
+        /// <param name="machineName">The machine name.</param>
+        /// <returns>The process name for the process if it could be found; otherwise, null.</returns>
+        public static string? GetProcessName(int processId, string machineName)
+        {
+            if (IsRemoteMachine(machineName))
+            {
+                // remote case: we take the hit of looping through all results
+                ProcessInfo[] processInfos = NtProcessManager.GetProcessInfos(machineName, isRemoteMachine: true);
+                foreach (ProcessInfo processInfo in processInfos)
+                {
+                    if (processInfo.ProcessId == processId)
+                    {
+                        return processInfo.ProcessName;
+                    }
+                }
+            }
+            else
+            {
+                // local case: do not use performance counter and also attempt to get the matching (by pid) process only
+
+                string? processName = Interop.Kernel32.GetProcessName((uint)processId);
+                if (processName is not null)
+                {
+                    return NtProcessInfoHelper.GetProcessShortName(processName);
+                }
+            }
+
+            return null;
+        }
+
+
         /// <summary>Gets the IDs of all processes on the specified machine.</summary>
         /// <param name="machineName">The machine to examine.</param>
         /// <returns>An array of process IDs from the specified machine.</returns>