Isolate the collection of the ProcessData (Buildalyzer#289)

Author: Corniel

src/Buildalyzer/Environment/DotNetInfoResolver.cs

@@ -42,7 +42,7 @@ private DotNetInfo Execute(IOPath projectPath, IOPath dotNetExePath)
         processRunner.Start();
         processRunner.WaitForExit(GetWaitTime());
 
-        var info = DotNetInfo.Parse(processRunner.Output);
+        var info = DotNetInfo.Parse(processRunner.Data.Output);
         Cache[projectPath] = info;
         return info;
     }

src/Buildalyzer/Environment/ProcessRunner.cs

@@ -3,15 +3,15 @@
 
 namespace Buildalyzer.Environment;
 
-internal class ProcessRunner : IDisposable
+internal sealed class ProcessRunner : IDisposable
 {
     private readonly ILogger Logger;
-
-    public List<string> Output { get; } = new List<string>();
-    public List<string> Error { get; } = new List<string>();
+    private readonly ProcessDataCollector Collector;
 
     public int ExitCode => Process.ExitCode;
 
+    public ProcessData Data => Collector.Data;
+
     private Process Process { get; }
 
     public Action Exited { get; set; }
@@ -35,7 +35,10 @@ public ProcessRunner(
                 UseShellExecute = false,
                 RedirectStandardOutput = true,
                 RedirectStandardError = true
-            }
+            },
+
+            // Raises Process.Exited immediately instead of when checked via .WaitForExit() or .HasExited
+            EnableRaisingEvents = true,
         };
 
         // Copy over environment variables
@@ -48,25 +51,11 @@ public ProcessRunner(
             }
         }
 
-        Process.EnableRaisingEvents = true;  // Raises Process.Exited immediately instead of when checked via .WaitForExit() or .HasExited
-        Process.Exited += ProcessExited;
+        Process.OutputDataReceived += OutputDataReceived;
+        Process.ErrorDataReceived += ErrorDataReceived;
+        Process.Exited += OnExit;
 
-        Process.OutputDataReceived += (_, e) =>
-        {
-            if (!string.IsNullOrEmpty(e.Data))
-            {
-                Output.Add(e.Data);
-                Logger.LogDebug("{Data}{NewLine}", e.Data, System.Environment.NewLine);
-            }
-        };
-        Process.ErrorDataReceived += (_, e) =>
-        {
-            if (!string.IsNullOrEmpty(e.Data))
-            {
-                Error.Add(e.Data);
-                Logger.LogDebug("{Data}{NewLine}", e.Data, System.Environment.NewLine);
-            }
-        };
+        Collector = new(Process);
     }
 
     public ProcessRunner Start()
@@ -83,16 +72,6 @@ public ProcessRunner Start()
         return this;
     }
 
-    private void ProcessExited(object? sender, EventArgs e)
-    {
-        Exited?.Invoke();
-        Logger.LogDebug(
-            "Process {Id} exited with code {ExitCode}{NewLine}",
-            Process.Id,
-            Process.ExitCode,
-            System.Environment.NewLine);
-    }
-
     public void WaitForExit() => Process.WaitForExit();
 
     public bool WaitForExit(int timeout)
@@ -108,9 +87,40 @@ public bool WaitForExit(int timeout)
         return exited;
     }
 
+    private void OutputDataReceived(object sender, DataReceivedEventArgs e)
+    {
+        if (!string.IsNullOrEmpty(e.Data))
+        {
+            Logger.LogDebug("{Data}{NewLine}", e.Data, NewLine);
+        }
+    }
+
+    private void ErrorDataReceived(object sender, DataReceivedEventArgs e)
+    {
+        if (!string.IsNullOrEmpty(e.Data))
+        {
+            Logger.LogError("{Data}{NewLine}", e.Data, NewLine);
+        }
+    }
+
+    private void OnExit(object? sender, EventArgs e)
+    {
+        Exited?.Invoke();
+        Logger.LogDebug(
+            "Process {Id} exited with code {ExitCode}{NewLine}",
+            Process.Id,
+            Process.ExitCode,
+            NewLine);
+    }
+
     public void Dispose()
     {
-        Process.Exited -= ProcessExited;
+        Process.OutputDataReceived -= OutputDataReceived;
+        Process.ErrorDataReceived -= ErrorDataReceived;
+        Process.Exited -= OnExit;
         Process.Close();
+        Collector.Dispose();
     }
+
+    private static string NewLine => System.Environment.NewLine;
 }

src/Buildalyzer/ProcessData.cs

@@ -0,0 +1,14 @@
+namespace Buildalyzer;
+
+/// <summary>The data received during a <see cref="Process" />.</summary>
+[DebuggerDisplay("Output = {Output.Length}, Error = {Error.Length}")]
+public sealed class ProcessData(
+    ImmutableArray<string> output,
+    ImmutableArray<string> error)
+{
+    /// <summary>The collected output of the process.</summary>
+    public ImmutableArray<string> Output { get; } = output;
+
+    /// <summary>The collected errors of the process.</summary>
+    public ImmutableArray<string> Error { get; } = error;
+}

src/Buildalyzer/ProcessDataCollector.cs

@@ -0,0 +1,46 @@
+namespace Buildalyzer;
+
+/// <summary>Collects the <see cref="ProcessData"/> durring a <see cref="System.Diagnostics.Process"/>.</summary>
+[DebuggerDisplay("ExitCode = {Process.ExitCode}, Output = {Process.Output.Length}, Error = {Process.Error.Length}")]
+internal sealed class ProcessDataCollector : IDisposable
+{
+    private readonly Process Process;
+    private readonly List<string> Output = [];
+    private readonly List<string> Error = [];
+
+    public ProcessDataCollector(Process process)
+    {
+        Process = process;
+        Process.OutputDataReceived += OutputDataReceived;
+        Process.ErrorDataReceived += ErrorDataReceived;
+    }
+
+    public ProcessData Data => new(
+        Output.ToImmutableArray(),
+        Error.ToImmutableArray());
+
+    private void OutputDataReceived(object? sender, DataReceivedEventArgs e) => Add(e.Data, Output);
+
+    private void ErrorDataReceived(object? sender, DataReceivedEventArgs e) => Add(e.Data, Error);
+
+    private static void Add(string? value, List<string> buffer)
+    {
+        if (value is { Length: > 0 })
+        {
+            buffer.Add(value);
+        }
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        if (!Disposed)
+        {
+            Process.OutputDataReceived -= OutputDataReceived;
+            Process.ErrorDataReceived -= ErrorDataReceived;
+            Disposed = true;
+        }
+    }
+
+    private bool Disposed;
+}