fix: Add ConfigureAwait(false) to remaining Task.WhenAll statements

thomhurst · claude · thomhurst · commit 58f705aa025f · 2025-08-08T23:56:46.000+01:00
Found and fixed additional methods that were returning Task.WhenAll directly without awaiting with ConfigureAwait(false). This completes the comprehensive ConfigureAwait(false) implementation across the entire library. Fixed files: - BatchAsyncProcessor.cs & BatchAsyncProcessor_1.cs - ParallelAsyncProcessor.cs & ParallelAsyncProcessor_1.cs - UnboundedParallelAsyncProcessor.cs & UnboundedParallelAsyncProcessor_1.cs - ResultBatchAsyncProcessor_1.cs & ResultBatchAsyncProcessor_2.cs - ResultParallelAsyncProcessor_1.cs & ResultParallelAsyncProcessor_2.cs - ResultUnboundedParallelAsyncProcessor_1.cs & ResultUnboundedParallelAsyncProcessor_2.cs All methods now properly use async/await with ConfigureAwait(false) pattern. All 498 tests pass. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor.cs b/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor.cs
@@ -24,8 +24,8 @@ internal override async Task Process()
         }
     }
 
-    private Task ProcessBatch(ActionTaskWrapper[] taskWrappers)
+    private async Task ProcessBatch(ActionTaskWrapper[] taskWrappers)
     {
-        return Task.WhenAll(taskWrappers.Select(tw => tw.Process(CancellationToken)));
+        await Task.WhenAll(taskWrappers.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/BatchAsyncProcessor_1.cs
@@ -25,8 +25,8 @@ internal override async Task Process()
         }
     }
 
-    private Task ProcessBatch(ItemTaskWrapper<TInput>[] currentBatch)
+    private async Task ProcessBatch(ItemTaskWrapper<TInput>[] currentBatch)
     {
-        return Task.WhenAll(currentBatch.Select(tw => tw.Process(CancellationToken)));
+        await Task.WhenAll(currentBatch.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor.cs b/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor.cs
@@ -11,13 +11,13 @@ internal ParallelAsyncProcessor(int count, Func<Task> taskSelector, Cancellation
         _isIOBound = isIOBound;
     }
 
-    internal override Task Process()
+    internal override async Task Process()
     {
         // For I/O-bound tasks, don't use Task.Run wrapper as it adds unnecessary overhead
         // The tasks are already async and won't block threads
         if (_isIOBound)
         {
-            return Task.WhenAll(TaskWrappers.Select(taskWrapper => 
+            await Task.WhenAll(TaskWrappers.Select(taskWrapper => 
             {
                 var task = taskWrapper.Process(CancellationToken);
                 // Fast-path for already completed tasks
@@ -26,10 +26,11 @@ internal override Task Process()
                     return task;
                 }
                 return task;
-            }));
+            })).ConfigureAwait(false);
+            return;
         }
 
         // For CPU-bound tasks, use Task.Run to offload to ThreadPool
-        return Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken))));
+        await Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken)))).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/ParallelAsyncProcessor_1.cs
@@ -11,13 +11,13 @@ internal ParallelAsyncProcessor(IEnumerable<TInput> items, Func<TInput, Task> ta
         _isIOBound = isIOBound;
     }
 
-    internal override Task Process()
+    internal override async Task Process()
     {
         // For I/O-bound tasks, don't use Task.Run wrapper as it adds unnecessary overhead
         // The tasks are already async and won't block threads
         if (_isIOBound)
         {
-            return Task.WhenAll(TaskWrappers.Select(taskWrapper => 
+            await Task.WhenAll(TaskWrappers.Select(taskWrapper => 
             {
                 var task = taskWrapper.Process(CancellationToken);
                 // Fast-path for already completed tasks
@@ -26,10 +26,11 @@ internal override Task Process()
                     return task;
                 }
                 return task;
-            }));
+            })).ConfigureAwait(false);
+            return;
         }
 
         // For CPU-bound tasks, use Task.Run to offload to ThreadPool
-        return Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken))));
+        await Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken)))).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_1.cs
@@ -26,8 +26,8 @@ internal override async Task Process()
         }
     }
 
-    private Task ProcessBatch(ActionTaskWrapper<TOutput>[] batch)
+    private async Task ProcessBatch(ActionTaskWrapper<TOutput>[] batch)
     {
-        return Task.WhenAll(batch.Select(tw => tw.Process(CancellationToken)));
+        await Task.WhenAll(batch.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_2.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultBatchAsyncProcessor_2.cs
@@ -22,8 +22,8 @@ internal override async Task Process()
         }
     }
 
-    private Task ProcessBatch(ItemTaskWrapper<TInput, TOutput>[] currentBatch)
+    private async Task ProcessBatch(ItemTaskWrapper<TInput, TOutput>[] currentBatch)
     {
-        return Task.WhenAll(currentBatch.Select(tw => tw.Process(CancellationToken)));
+        await Task.WhenAll(currentBatch.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_1.cs
@@ -11,13 +11,13 @@ internal ResultParallelAsyncProcessor(int count, Func<Task<TOutput>> taskSelecto
         _isIOBound = isIOBound;
     }
 
-    internal override Task Process()
+    internal override async Task Process()
     {
         // For I/O-bound tasks, don't use Task.Run wrapper as it adds unnecessary overhead
         // The tasks are already async and won't block threads
         if (_isIOBound)
         {
-            return Task.WhenAll(TaskWrappers.Select(taskWrapper => 
+            await Task.WhenAll(TaskWrappers.Select(taskWrapper => 
             {
                 var task = taskWrapper.Process(CancellationToken);
                 // Fast-path for already completed tasks
@@ -26,10 +26,11 @@ internal override Task Process()
                     return task;
                 }
                 return task;
-            }));
+            })).ConfigureAwait(false);
+            return;
         }
 
         // For CPU-bound tasks, use Task.Run to offload to ThreadPool
-        return Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken))));
+        await Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken)))).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_2.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultParallelAsyncProcessor_2.cs
@@ -11,13 +11,13 @@ internal ResultParallelAsyncProcessor(IEnumerable<TInput> items, Func<TInput, Ta
         _isIOBound = isIOBound;
     }
 
-    internal override Task Process()
+    internal override async Task Process()
     {
         // For I/O-bound tasks, don't use Task.Run wrapper as it adds unnecessary overhead
         // The tasks are already async and won't block threads
         if (_isIOBound)
         {
-            return Task.WhenAll(TaskWrappers.Select(taskWrapper => 
+            await Task.WhenAll(TaskWrappers.Select(taskWrapper => 
             {
                 var task = taskWrapper.Process(CancellationToken);
                 // Fast-path for already completed tasks
@@ -26,10 +26,11 @@ internal override Task Process()
                     return task;
                 }
                 return task;
-            }));
+            })).ConfigureAwait(false);
+            return;
         }
 
         // For CPU-bound tasks, use Task.Run to offload to ThreadPool
-        return Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken))));
+        await Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken)))).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultUnboundedParallelAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultUnboundedParallelAsyncProcessor_1.cs
@@ -13,7 +13,7 @@ internal ResultUnboundedParallelAsyncProcessor(int count, Func<Task<TOutput>> ta
     {
     }
 
-    internal override Task Process()
+    internal override async Task Process()
     {
         // Start ALL tasks immediately without any throttling
         // This provides true unbounded parallelism
@@ -28,6 +28,6 @@ internal override Task Process()
             return task;
         });
 
-        return Task.WhenAll(tasks);
+        await Task.WhenAll(tasks).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultUnboundedParallelAsyncProcessor_2.cs b/EnumerableAsyncProcessor/RunnableProcessors/ResultProcessors/ResultUnboundedParallelAsyncProcessor_2.cs
@@ -13,7 +13,7 @@ internal ResultUnboundedParallelAsyncProcessor(IEnumerable<TInput> items, Func<T
     {
     }
 
-    internal override Task Process()
+    internal override async Task Process()
     {
         // Start ALL tasks immediately without any throttling
         // This provides true unbounded parallelism
@@ -28,6 +28,6 @@ internal override Task Process()
             return task;
         });
 
-        return Task.WhenAll(tasks);
+        await Task.WhenAll(tasks).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/UnboundedParallelAsyncProcessor.cs b/EnumerableAsyncProcessor/RunnableProcessors/UnboundedParallelAsyncProcessor.cs
@@ -13,7 +13,7 @@ internal UnboundedParallelAsyncProcessor(int count, Func<Task> taskSelector, Can
     {
     }
 
-    internal override Task Process()
+    internal override async Task Process()
     {
         // Start ALL tasks immediately without any throttling
         // This provides true unbounded parallelism
@@ -28,6 +28,6 @@ internal override Task Process()
             return task;
         });
 
-        return Task.WhenAll(tasks);
+        await Task.WhenAll(tasks).ConfigureAwait(false);
     }
 }
diff --git a/EnumerableAsyncProcessor/RunnableProcessors/UnboundedParallelAsyncProcessor_1.cs b/EnumerableAsyncProcessor/RunnableProcessors/UnboundedParallelAsyncProcessor_1.cs
@@ -13,7 +13,7 @@ internal UnboundedParallelAsyncProcessor(IEnumerable<TInput> items, Func<TInput,
     {
     }
 
-    internal override Task Process()
+    internal override async Task Process()
     {
         // Start ALL tasks immediately without any throttling
         // This provides true unbounded parallelism
@@ -28,6 +28,6 @@ internal override Task Process()
             return task;
         });
 
-        return Task.WhenAll(tasks);
+        await Task.WhenAll(tasks).ConfigureAwait(false);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,8 @@ internal override async Task Process()`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`
`27`		`- private Task ProcessBatch(ActionTaskWrapper[] taskWrappers)`
	`27`	`+ private async Task ProcessBatch(ActionTaskWrapper[] taskWrappers)`
`28`	`28`	`{`
`29`		`- return Task.WhenAll(taskWrappers.Select(tw => tw.Process(CancellationToken)));`
	`29`	`+ await Task.WhenAll(taskWrappers.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);`
`30`	`30`	`}`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,8 @@ internal override async Task Process()`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
`28`		`- private Task ProcessBatch(ItemTaskWrapper<TInput>[] currentBatch)`
	`28`	`+ private async Task ProcessBatch(ItemTaskWrapper<TInput>[] currentBatch)`
`29`	`29`	`{`
`30`		`- return Task.WhenAll(currentBatch.Select(tw => tw.Process(CancellationToken)));`
	`30`	`+ await Task.WhenAll(currentBatch.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,13 +11,13 @@ internal ParallelAsyncProcessor(int count, Func<Task> taskSelector, Cancellation`
`11`	`11`	`_isIOBound = isIOBound;`
`12`	`12`	`}`
`13`	`13`
`14`		`- internal override Task Process()`
	`14`	`+ internal override async Task Process()`
`15`	`15`	`{`
`16`	`16`	`// For I/O-bound tasks, don't use Task.Run wrapper as it adds unnecessary overhead`
`17`	`17`	`// The tasks are already async and won't block threads`
`18`	`18`	`if (_isIOBound)`
`19`	`19`	`{`
`20`		`- return Task.WhenAll(TaskWrappers.Select(taskWrapper =>`
	`20`	`+ await Task.WhenAll(TaskWrappers.Select(taskWrapper =>`
`21`	`21`	`{`
`22`	`22`	`var task = taskWrapper.Process(CancellationToken);`
`23`	`23`	`// Fast-path for already completed tasks`
`@@ -26,10 +26,11 @@ internal override Task Process()`
`26`	`26`	`return task;`
`27`	`27`	`}`
`28`	`28`	`return task;`
`29`		`- }));`
	`29`	`+ })).ConfigureAwait(false);`
	`30`	`+ return;`
`30`	`31`	`}`
`31`	`32`
`32`	`33`	`// For CPU-bound tasks, use Task.Run to offload to ThreadPool`
`33`		`- return Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken))));`
	`34`	`+ await Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken)))).ConfigureAwait(false);`
`34`	`35`	`}`
`35`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,8 +26,8 @@ internal override async Task Process()`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`		`- private Task ProcessBatch(ActionTaskWrapper<TOutput>[] batch)`
	`29`	`+ private async Task ProcessBatch(ActionTaskWrapper<TOutput>[] batch)`
`30`	`30`	`{`
`31`		`- return Task.WhenAll(batch.Select(tw => tw.Process(CancellationToken)));`
	`31`	`+ await Task.WhenAll(batch.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,8 +22,8 @@ internal override async Task Process()`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`- private Task ProcessBatch(ItemTaskWrapper<TInput, TOutput>[] currentBatch)`
	`25`	`+ private async Task ProcessBatch(ItemTaskWrapper<TInput, TOutput>[] currentBatch)`
`26`	`26`	`{`
`27`		`- return Task.WhenAll(currentBatch.Select(tw => tw.Process(CancellationToken)));`
	`27`	`+ await Task.WhenAll(currentBatch.Select(tw => tw.Process(CancellationToken))).ConfigureAwait(false);`
`28`	`28`	`}`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,13 +11,13 @@ internal ResultParallelAsyncProcessor(int count, Func<Task<TOutput>> taskSelecto`
`11`	`11`	`_isIOBound = isIOBound;`
`12`	`12`	`}`
`13`	`13`
`14`		`- internal override Task Process()`
	`14`	`+ internal override async Task Process()`
`15`	`15`	`{`
`16`	`16`	`// For I/O-bound tasks, don't use Task.Run wrapper as it adds unnecessary overhead`
`17`	`17`	`// The tasks are already async and won't block threads`
`18`	`18`	`if (_isIOBound)`
`19`	`19`	`{`
`20`		`- return Task.WhenAll(TaskWrappers.Select(taskWrapper =>`
	`20`	`+ await Task.WhenAll(TaskWrappers.Select(taskWrapper =>`
`21`	`21`	`{`
`22`	`22`	`var task = taskWrapper.Process(CancellationToken);`
`23`	`23`	`// Fast-path for already completed tasks`
`@@ -26,10 +26,11 @@ internal override Task Process()`
`26`	`26`	`return task;`
`27`	`27`	`}`
`28`	`28`	`return task;`
`29`		`- }));`
	`29`	`+ })).ConfigureAwait(false);`
	`30`	`+ return;`
`30`	`31`	`}`
`31`	`32`
`32`	`33`	`// For CPU-bound tasks, use Task.Run to offload to ThreadPool`
`33`		`- return Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken))));`
	`34`	`+ await Task.WhenAll(TaskWrappers.Select(taskWrapper => Task.Run(() => taskWrapper.Process(CancellationToken)))).ConfigureAwait(false);`
`34`	`35`	`}`
`35`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ internal ResultUnboundedParallelAsyncProcessor(int count, Func<Task<TOutput>> ta`
`13`	`13`	`{`
`14`	`14`	`}`
`15`	`15`
`16`		`- internal override Task Process()`
	`16`	`+ internal override async Task Process()`
`17`	`17`	`{`
`18`	`18`	`// Start ALL tasks immediately without any throttling`
`19`	`19`	`// This provides true unbounded parallelism`
`@@ -28,6 +28,6 @@ internal override Task Process()`
`28`	`28`	`return task;`
`29`	`29`	`});`
`30`	`30`
`31`		`- return Task.WhenAll(tasks);`
	`31`	`+ await Task.WhenAll(tasks).ConfigureAwait(false);`
`32`	`32`	`}`
`33`	`33`	`}`