High-Performance .NET: Async, Multithreading, and Parallel Programming Parallel Loops in .NET Created: 19 Jan 2026 Updated: 19 Jan 2026

Managing State with ParallelLoopState and Local State

When working with Parallel.For or Parallel.ForEach, there are times when simply running iterations in parallel isn't enough. You might need to stop the loop early if a certain condition is met or maintain a private counter for each thread to avoid performance-killing "locks."

As highlighted in Jeff McNamara’s Ultimate C# for High-Performance Applications, C# provides two primary ways to manage this: ParallelLoopState and Local State.

1. Controlling the Loop: ParallelLoopState

The ParallelLoopState parameter allows you to influence the loop from the inside. It provides two main methods to exit a loop prematurely: Stop() and Break().

Stop vs. Break

MethodDescription
Stop()Tells the loop to stop as soon as possible. No new iterations will start. Use this when you've found what you need and want to quit immediately.
Break()Ensures all iterations before the current index are completed, but no iterations after the current index will start. Use this if you need to maintain a level of sequential logic.


Simple Example: Searching for a Target

Imagine you are looking for a specific value in a large collection. Once you find it, there is no need to keep the CPU working on the rest.

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class SearchExample
{
public void FindValue(List<string> items, string target)
{
Parallel.ForEach(items, (item, state) =>
{
if (item == target)
{
Console.WriteLine($"Found {target}! Stopping all threads...");
// Halts the loop because the goal is reached
state.Stop();
}

// This might still run for a few iterations
// until the "Stop" command propagates to all threads
Console.WriteLine($"Checking: {item}");
});
}
}


Using state.Break() in Parallel Loops

The Break() method is used when you want to stop a parallel loop but ensure that all iterations with an index lower than the current one are completed. It is ideal for scenarios where you reach a threshold or a specific data point and no longer need to process items appearing "after" it in the collection.

Example Code: Threshold-Based Break

In this example, we process a list of numbers. As soon as a number exceeds 50, we call Break(). This ensures that all numbers smaller than the one that triggered the break are processed, while preventing new iterations for higher numbers.

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class ParallelBreakDemo
{
public void Execute()
{
var data = new List<int> { 10, 20, 30, 60, 40, 50 };

Parallel.ForEach(data, (number, state) =>
{
if (number > 55)
{
Console.WriteLine($"[Break] Number {number} exceeded threshold. Stopping further items...");
state.Break();
return;
}

// Perform task
Console.WriteLine($"Processing: {number}");
});

Console.WriteLine("Loop finished.");
}
}

Key Takeaway

  1. Behavior: Unlike Stop(), which halts everything immediately, Break() guarantees that all "earlier" elements in the source collection are handled before the loop fully exits.
  2. Performance: It helps save CPU resources by not starting unnecessary tasks once your criteria are met

2. Optimizing Performance: Local State

When multiple threads try to update a single shared variable (like a sum), it causes "contention." Each thread has to wait for the others to finish, which makes the parallel loop slower than a normal one.

Local State solves this by giving each thread its own "private" variable. Each thread works on its own version of the data, and at the very end, all these private versions are combined into one final result.

Simple Example: Summing Numbers

In this example, instead of every thread fighting to update a single totalSum, each thread maintains its own localSum.

void CalculateSum()
{
int[] numbers = Enumerable.Range(1, 1000).ToArray();
long totalSum = 0;
var lockObject = new Lock();
var lockObject2 = new object();
long totalSum2 = 0;
long totalSum3WithInterlocked = 0;

Parallel.ForEach(numbers,
() => 0L, // Initialize the local state (per thread) to 0
(number, state, localSum) =>
{
localSum += number; // Add to the thread's private sum
return localSum; // Pass it to the next iteration on this thread
},
(finalLocalSum) =>
{
// This runs once per thread at the end.
// We safely add the thread's total to the main total.
using (lockObject.EnterScope())
{
totalSum += finalLocalSum;
}
lock(lockObject2)
totalSum2 += finalLocalSum;
Interlocked.Add(ref totalSum3WithInterlocked, finalLocalSum);
}
);

Console.WriteLine($"Total Sum: {totalSum}");
Console.WriteLine($"Total Sum2: {totalSum2}");
Console.WriteLine($"Total Sum3WithInterlocked: {totalSum3WithInterlocked}");
}

Key Takeaways

ParallelLoopState

  1. Use Case: Exiting a loop early based on a condition (like finding a file or encountering an error).
  2. Benefit: Saves CPU cycles by not performing unnecessary work.

Local State

  1. Use Case: Aggregating data (sums, counts, or lists) across multiple threads.
  2. Benefit: Drastically improves performance by reducing the need for lock operations during the main loop execution.
Share this lesson:

Details

Category
High-Performance .NET: Async, Multithreading, and Parallel Programming
Sub: Parallel Loops in .NET
View All Courses Back to Lessons

Navigation

Progress 8 / 23
Start 35% Complete
Parallel.Foreach Error Handling in Parallel Loops
Statistics
7 Lessons in Parallel Loops in .NET
4 SubCategories in High-Performance .NET: Async, Multithreading, and Parallel Programming
23 Total Lessons in High-Performance .NET: Async, Multithreading, and Parallel Programming