ParallelHelperEx 1.0.5

ParallelHelperEx

A modern C# library for efficient, parallel, and asynchronous processing of collections with real-time metrics reporting.

Features

• Parallel processing with configurable degree of parallelism
• Streaming/iterator-based input (no forced materialization)
• Real-time metrics via IProgress<ParallelProcessingMetrics>
• Graceful error handling (errors are logged, processing continues)
• Proper resource cleanup with IAsyncDisposable

Installation

Add the ParallelHelperEx project to your solution and reference it from your project.

Usage Examples

Parallel ForEach (Action)

using ParallelHelperEx;

var items = Enumerable.Range(1, 1000);
await items.ParallelForEachAsync(async item =>
{
    // Your async work here
    await Task.Delay(10);
});

Parallel ForEach with Cancellation, Logging, and Metrics

var cts = new CancellationTokenSource();
var logger = /* your ILogger instance */;
var progress = new Progress<ParallelProcessingMetrics>(m =>
{
    Console.WriteLine($"Processed: {m.ProcessedCount}, Errors: {m.ErrorCount}, Elapsed: {m.Elapsed.TotalSeconds:F1}s, Throughput: {m.ItemsProcessedPerSecond:F2}/sec");
});

await items.ParallelForEachAsync(
    async (item, ct) => { /* ... */ },
    maxDegreeOfParallelism: 8,
    logger: logger,
    progress: progress,
    cancellationToken: cts.Token
);

Parallel Select (Transform)

var results = await items.ParallelSelectAsync(async item =>
{
    await Task.Delay(5);
    return item * 2;
}, maxDegreeOfParallelism: 4);

Metrics Reporting

The ParallelProcessingMetrics class provides:

• ProcessedCount: Number of items processed
• ErrorCount: Number of errors encountered
• StartTime, EndTime, Elapsed: Timing info
• ItemsProcessedPerSecond: Throughput

Metrics are reported every second and once at the end.

Proper Disposal

If you use ToParallelQueue, always dispose:

await using var queue = items.ToParallelQueue(async item => { /* ... */ }, 4);
// ...
await queue.CompleteAsync();
// or just let the using block end

Best Practices

• Use IProgress<ParallelProcessingMetrics> for real-time UI or logging.
• Always dispose of queues with await using or DisposeAsync().
• Tune maxDegreeOfParallelism for your workload.
• For large or memory-sensitive workloads, consider making channel capacity configurable.

License

MIT