fix: dispose process handles and clear pid caches

Author: PrimeBuild-pc

Services/ProcessMonitorManagerService.cs

@@ -432,12 +432,11 @@ private async Task OnProcessStoppedAsync(ProcessEventArgs e)
             try
             {
                 this.persistentRuleAutoApplyService.MarkProcessExited(e.Process.ProcessId);
+                this.coreMaskService.UnregisterMaskApplication(e.Process.ProcessId);
+                this.processService.UntrackProcess(e.Process.ProcessId);
 
                 if (this.runningAssociatedProcesses.TryRemove(e.Process.ProcessId, out _))
                 {
-                    this.coreMaskService.UnregisterMaskApplication(e.Process.ProcessId);
-                    this.processService.UntrackProcess(e.Process.ProcessId);
-
                     // Check if there are any other associated processes still running
                     var remainingProcesses = this.runningAssociatedProcesses.Values.ToList();
                     await this.DeterminePowerPlanAsync(remainingProcesses);

Services/ProcessService.cs

@@ -110,15 +110,26 @@ internal ProcessService(
         public async Task<ObservableCollection<ProcessModel>> GetProcessesAsync()
         {
             return await Task.Run(() =>
+                new ObservableCollection<ProcessModel>(this.EnumerateProcessModels())).ConfigureAwait(false);
+        }
+
+        private List<ProcessModel> EnumerateProcessModels(Func<ProcessModel, bool>? filter = null)
+        {
+            var foregroundProcessId = this.foregroundProcessService?.TryGetForegroundProcessId();
+            var models = new List<ProcessModel>();
+            foreach (var process in Process.GetProcesses())
             {
-                var foregroundProcessId = this.foregroundProcessService?.TryGetForegroundProcessId();
-                var processes = Process.GetProcesses()
-                    .Select(process => this.TryCreateProcessModel(process, foregroundProcessId))
-                    .OfType<ProcessModel>()
-                    .OrderBy(p => p.Name);
+                using (process)
+                {
+                    var model = this.TryCreateProcessModel(process, foregroundProcessId);
+                    if (model != null && (filter == null || filter(model)))
+                    {
+                        models.Add(model);
+                    }
+                }
+            }
 
-                return new ObservableCollection<ProcessModel>(processes);
-            }).ConfigureAwait(false);
+            return models.OrderBy(process => process.Name).ToList();
         }
 
         private sealed class CpuSample
@@ -988,7 +999,7 @@ public async Task<bool> ClearProcessCpuSetAsync(ProcessModel process)
             {
                 try
                 {
-                    var process = Process.GetProcessById(processId);
+                    using var process = Process.GetProcessById(processId);
                     return this.CreateProcessModel(process);
                 }
                 catch
@@ -1000,20 +1011,29 @@ public async Task<bool> ClearProcessCpuSetAsync(ProcessModel process)
 
         public async Task<IEnumerable<ProcessModel>> GetProcessesByNameAsync(string executableName)
         {
-            return await Task.Run(() =>
+            return await Task.Run<IEnumerable<ProcessModel>>(() =>
             {
                 try
                 {
                     var foregroundProcessId = this.foregroundProcessService?.TryGetForegroundProcessId();
-                    var processes = Process.GetProcessesByName(executableName)
-                        .Select(process => this.TryCreateProcessModel(process, foregroundProcessId))
-                        .OfType<ProcessModel>();
+                    var models = new List<ProcessModel>();
+                    foreach (var process in Process.GetProcessesByName(executableName))
+                    {
+                        using (process)
+                        {
+                            var model = this.TryCreateProcessModel(process, foregroundProcessId);
+                            if (model != null)
+                            {
+                                models.Add(model);
+                            }
+                        }
+                    }
 
-                    return processes;
+                    return models;
                 }
                 catch
                 {
-                    return Enumerable.Empty<ProcessModel>();
+                    return Array.Empty<ProcessModel>();
                 }
             }).ConfigureAwait(false);
         }
@@ -1026,32 +1046,15 @@ public async Task<bool> IsProcessRunningAsync(string executableName)
 
         public async Task<IEnumerable<ProcessModel>> GetProcessesWithPathsAsync()
         {
-            return await Task.Run(() =>
-            {
-                var foregroundProcessId = this.foregroundProcessService?.TryGetForegroundProcessId();
-                var processes = Process.GetProcesses()
-                    .Select(process => this.TryCreateProcessModel(process, foregroundProcessId))
-                    .OfType<ProcessModel>()
-                    .Where(p => !string.IsNullOrEmpty(p.ExecutablePath))
-                    .OrderBy(p => p.Name);
-
-                return processes;
-            }).ConfigureAwait(false);
+            return await Task.Run<IEnumerable<ProcessModel>>(() =>
+                this.EnumerateProcessModels(process => !string.IsNullOrEmpty(process.ExecutablePath))).ConfigureAwait(false);
         }
 
         public async Task<ObservableCollection<ProcessModel>> GetActiveApplicationsAsync()
         {
             return await Task.Run(() =>
-            {
-                var foregroundProcessId = this.foregroundProcessService?.TryGetForegroundProcessId();
-                var processes = Process.GetProcesses()
-                    .Select(process => this.TryCreateProcessModel(process, foregroundProcessId))
-                    .OfType<ProcessModel>()
-                    .Where(p => p.HasVisibleWindow)
-                    .OrderBy(p => p.Name);
-
-                return new ObservableCollection<ProcessModel>(processes);
-            }).ConfigureAwait(false);
+                new ObservableCollection<ProcessModel>(
+                    this.EnumerateProcessModels(process => process.HasVisibleWindow))).ConfigureAwait(false);
         }
 
         public async Task<bool> IsProcessStillRunning(ProcessModel process)
@@ -1060,8 +1063,8 @@ public async Task<bool> IsProcessStillRunning(ProcessModel process)
             {
                 try
                 {
-                    var p = Process.GetProcessById(process.ProcessId);
-                    return !p.HasExited;
+                    using var targetProcess = Process.GetProcessById(process.ProcessId);
+                    return !targetProcess.HasExited;
                 }
                 catch (ArgumentException)
                 {