added ConfigureAwait(false) to all await statements

Author: santisq

src/PSParallelPipeline/Commands/InvokeParallelCommand.cs

@@ -59,18 +59,12 @@ protected override void BeginProcessing()
             .AddFunctions(Functions, this)
             .AddVariables(Variables, this);
 
-        PoolSettings poolSettings = new()
-        {
-            MaxRunspaces = ThrottleLimit,
-            UseNewRunspace = UseNewRunspace,
-            InitialSessionState = iss
-        };
+        PoolSettings poolSettings = new(
+            ThrottleLimit, UseNewRunspace, iss);
 
-        TaskSettings workerSettings = new()
-        {
-            Script = ScriptBlock.ToString(),
-            UsingStatements = ScriptBlock.GetUsingParameters(this)
-        };
+        TaskSettings workerSettings = new(
+            ScriptBlock.ToString(),
+            ScriptBlock.GetUsingParameters(this));
 
         _worker = new Worker(poolSettings, workerSettings, _cts.Token);
         _worker.Run();

src/PSParallelPipeline/PSTask.cs

@@ -37,7 +37,9 @@ static internal async Task<PSTask> CreateAsync(
     {
         PSTask ps = new(runspacePool);
         SetStreams(ps._internalStreams, runspacePool.Streams);
-        ps.Runspace = await runspacePool.GetRunspaceAsync();
+        ps.Runspace = await runspacePool
+            .GetRunspaceAsync()
+            .ConfigureAwait(false);
 
         return ps
             .AddInput(input)
@@ -98,7 +100,7 @@ internal async Task InvokeAsync()
         try
         {
             using CancellationTokenRegistration _ = _pool.RegisterCancellation(Cancel);
-            await InvokePowerShellAsync(_powershell, OutputStreams.Success);
+            await InvokePowerShellAsync(_powershell, OutputStreams.Success).ConfigureAwait(false);
         }
         catch (Exception exception)
         {

src/PSParallelPipeline/PoolSettings.cs

@@ -2,7 +2,14 @@
 
 namespace PSParallelPipeline;
 
-internal record struct PoolSettings(
-    int MaxRunspaces,
-    bool UseNewRunspace,
-    InitialSessionState InitialSessionState);
+internal class PoolSettings(
+    int maxRunspaces,
+    bool useNewRunspace,
+    InitialSessionState initialSessionState)
+{
+    internal int MaxRunspaces { get; } = maxRunspaces;
+
+    internal bool UseNewRunspace { get; } = useNewRunspace;
+
+    internal InitialSessionState InitialSessionState { get; } = initialSessionState;
+}

src/PSParallelPipeline/RunspacePool.cs

@@ -8,28 +8,30 @@ namespace PSParallelPipeline;
 
 internal sealed class RunspacePool : IDisposable
 {
+    private readonly PoolSettings _settings;
+
     private readonly CancellationToken _token;
 
-    private readonly InitialSessionState _iss;
+    private InitialSessionState InitialSessionState { get => _settings.InitialSessionState; }
 
     private readonly ConcurrentQueue<Runspace> _pool = [];
 
     private readonly ConcurrentDictionary<Guid, Runspace> _created;
 
-    private readonly bool _useNew;
+    private bool UseNewRunspace { get => _settings.UseNewRunspace; }
 
     private readonly SemaphoreSlim _semaphore;
 
     internal PSOutputStreams Streams { get; }
 
-    internal int MaxRunspaces { get; }
+    internal int MaxRunspaces { get => _settings.MaxRunspaces; }
 
     internal RunspacePool(
         PoolSettings settings,
         PSOutputStreams streams,
         CancellationToken token)
     {
-        (MaxRunspaces, _useNew, _iss) = settings;
+        _settings = settings;
         Streams = streams;
         _token = token;
         _semaphore = new SemaphoreSlim(MaxRunspaces, MaxRunspaces);
@@ -45,7 +47,7 @@ internal void PushRunspace(Runspace runspace)
             return;
         }
 
-        if (_useNew)
+        if (UseNewRunspace)
         {
             runspace.Dispose();
             _created.TryRemove(runspace.InstanceId, out _);
@@ -61,15 +63,18 @@ internal CancellationTokenRegistration RegisterCancellation(Action callback) =>
 
     private Runspace CreateRunspace()
     {
-        Runspace rs = RunspaceFactory.CreateRunspace(_iss);
+        Runspace rs = RunspaceFactory.CreateRunspace(InitialSessionState);
         _created[rs.InstanceId] = rs;
         rs.Open();
         return rs;
     }
 
     internal async Task<Runspace> GetRunspaceAsync()
     {
-        await _semaphore.WaitAsync(_token);
+        await _semaphore
+            .WaitAsync(_token)
+            .ConfigureAwait(false);
+
         if (_pool.TryDequeue(out Runspace runspace))
         {
             return runspace;

src/PSParallelPipeline/TaskSettings.cs

@@ -2,6 +2,11 @@
 
 namespace PSParallelPipeline;
 
-internal record struct TaskSettings(
-    string Script,
-    Dictionary<string, object?> UsingStatements);
+internal class TaskSettings(
+    string script,
+    Dictionary<string, object?> usingStatements)
+{
+    internal string Script { get; } = script;
+
+    internal Dictionary<string, object?> UsingStatements { get; } = usingStatements;
+}

src/PSParallelPipeline/Worker.cs

@@ -33,17 +33,15 @@ internal Worker(
         _pool = new RunspacePool(poolSettings, _streams, _token);
     }
 
-    internal void Wait() => _worker?.GetAwaiter().GetResult();
+    internal void Wait() => _worker?.ConfigureAwait(false).GetAwaiter().GetResult();
 
     internal void Enqueue(object? input) => _input.Add(input, _token);
 
-    internal bool TryTake(out PSOutputData output) =>
-        _output.TryTake(out output, 0, _token);
+    internal bool TryTake(out PSOutputData output) => _output.TryTake(out output, 0, _token);
 
     internal void CompleteInputAdding() => _input.CompleteAdding();
 
-    internal IEnumerable<PSOutputData> GetConsumingEnumerable() =>
-        _output.GetConsumingEnumerable(_token);
+    internal IEnumerable<PSOutputData> GetConsumingEnumerable() => _output.GetConsumingEnumerable(_token);
 
     internal void Run() => _worker = Task.Run(Start, cancellationToken: _token);
 
@@ -57,13 +55,15 @@ private async Task Start()
             {
                 if (tasks.Count == tasks.Capacity)
                 {
-                    await ProcessAnyAsync(tasks);
+                    await ProcessAnyAsync(tasks).ConfigureAwait(false);
                 }
 
-                PSTask task = await PSTask.CreateAsync(
-                    input: input,
-                    runspacePool: _pool,
-                    settings: _taskSettings);
+                PSTask task = await PSTask
+                    .CreateAsync(
+                        input: input,
+                        runspacePool: _pool,
+                        settings: _taskSettings)
+                    .ConfigureAwait(false);
 
                 tasks.Add(task.InvokeAsync());
             }
@@ -72,16 +72,23 @@ private async Task Start()
         { }
         finally
         {
-            await Task.WhenAll(tasks);
+            await Task
+                .WhenAll(tasks)
+                .ConfigureAwait(false);
+
             _output.CompleteAdding();
         }
     }
 
     private static async Task ProcessAnyAsync(List<Task> tasks)
     {
-        Task task = await Task.WhenAny(tasks);
+        Task task = await Task
+            .WhenAny(tasks)
+            .ConfigureAwait(false);
+
         tasks.Remove(task);
-        await task;
+        await task
+            .ConfigureAwait(false);
     }
 
     public void Dispose()