processing-parallel-tasks

# .NET Parallel Processing

A guide for APIs and patterns for parallel processing of CPU-bound tasks.

**Quick Reference:** See [QUICKREF.md](QUICKREF.md) for essential patterns at a glance.

## 1. Core APIs

| API | Purpose |
|-----|---------|
| `Parallel.For`, `Parallel.ForEach` | CPU-bound parallel processing |
| `PLINQ (.AsParallel())` | LINQ query parallelization |
| `Partitioner<T>` | Large data partitioning |
| `ConcurrentDictionary<K,V>` | Thread-safe dictionary |

---

## 2. Parallel Class

### 2.1 Parallel.ForEach

```csharp
public sealed class ImageProcessor
{
    public void ProcessImages(IEnumerable<string> imagePaths)
    {
        var options = new ParallelOptions
        {
            MaxDegreeOfParallelism = Environment.ProcessorCount
        };

        Parallel.ForEach(imagePaths, options, path =>
        {
            ProcessImage(path);
        });
    }
}
```

### 2.2 Early Termination

```csharp
Parallel.For(0, data.Length, (i, state) =>
{
    if (data[i] == target)
    {
        state.Break();
    }
});
```

---

## 3. PLINQ

```csharp
var results = data
    .AsParallel()
    .WithDegreeOfParallelism(Environment.ProcessorCount)
    .Where(d => d.IsValid)
    .Select(d => Transform(d))
    .ToList();

// When order preservation is needed
var results = data
    .AsParallel()
    .AsOrdered()
    .Select(d => Process(d))
    .ToList();
```

---

## 4. Thread-Safe Collections

| Collection | Purpose |
|------------|---------|
| `ConcurrentDictionary<K,V>` | Thread-safe dictionary |
| `ConcurrentQueue<T>` | Thread-safe FIFO queue |
| `ConcurrentBag<T>` | Thread-safe unordered collection |

```csharp
// Collecting results during parallel processing
var results = new ConcurrentBag<Result>();

Parallel.ForEach(data, item =>
{
    var result = Process(item);
    results.Add(result);
});
```

---

## 5. ThreadLocal<T>

Prevents contention with thread-local variables

```csharp
private readonly ThreadLocal<StringBuilder> _localBuilder =
    new(() => ne