How to populate and return List<T> from Parallel.ForEach using partitioning

As an exercise you can do something like this:

var persons1 = new List<Person>();
var locker = new object();
Parallel.ForEach(
    persons,
    () => new List<Person>(), // initialize aggregate per thread 
    (person, loopState, subtotal) =>
    {
        subtotal.Add(person); // add current thread element to aggregate 
        return subtotal; // return current thread aggregate
    },
    p => // action to combine all threads results
    {
        lock (locker) // lock, cause List<T> is not a thread safe collection
        {
            persons1.AddRange(p);
        }
    }
);

This should not be used in production code though. What you should do usually depends on actual task you want to perform.

Parallel.ForEach doesn't have a method which returns results for each process as a list aggregate. You need to synchronize with some local variable defined outside the loop.

Microsoft has an example where they use a ConcurrentBag and add elements to this within each process, https://docs.microsoft.com/en-us/dotnet/standard/parallel-programming/how-to-write-a-simple-parallel-foreach-loop.

Alternatives to use Parallel.ForEach is AsParallel() from PLINQ. Parallel compared to PLINQ does take into account the current work on the CPU, where PLINQ just uses as much resources as it can - from Concurrency in C# Cookbook, 2nd Edition

I implemented several different ways to solve the issue below using Parallel with and without local list, PLINQ and Tasks.

When using Parallel I also tried using different kind of lists.

    public record struct Person(int Age);

    public static class Question {

        public static IList<Person> PLinq(IList<Person> input)
        {
            return input.AsParallel().Select(p =>
            {
                p.Age += 1;
                return p;
            }).ToList();
        }

        // Example from Microsoft uses ConcurrentBag
        // https://docs.microsoft.com/en-us/dotnet/standard/parallel-programming/how-to-write-a-simple-parallel-foreach-loop
        public static IList<Person> ParallelForEachConcurrentBag(IList<Person> input)
        {
            var persons = new ConcurrentBag<Person>();
            Parallel.ForEach(input, (p) =>
            {
                p.Age += 1;
                persons.Add(p);
            });
            return persons.ToList();
        }

        public static IList<Person> ParallelForEachLock(IList<Person> input)
        {
            object mutex = new();
            var persons = new List<Person>(input.Count);
            Parallel.ForEach(input, (p) =>
            {
                p.Age += 1;
                lock (mutex)
                {
                    persons.Add(p);
                }
            });
            return persons;
        }

        public static IList<Person> ParallelForEachLocalInitLock(IList<Person> input)
        {
            object mutex = new();
            var persons = new List<Person>(input.Count);

            Parallel.ForEach(
                source: input,
                localInit: () => new List<Person>(),
                body: (p, state, local) => {
                    p.Age += 1;
                    local.Add(p);
                    return local;
                },
                local =>
                {
                    lock (mutex)
                    {
                        persons.AddRange(local);
                    }
                });
            return persons;
        }

        public static IList<Person> ParallelForEachImmutable(IList<Person> input)
        {
            var persons = ImmutableList<Person>.Empty;
            Parallel.ForEach(input, (p) =>
            {
                p.Age += 1;
                ImmutableInterlocked.Update(ref persons, l => l.Add(p));
            });
            return persons;
        }

        public static IList<Person> ParallelForEachLocalInitImmutable(IList<Person> input)
        {
            var persons = ImmutableList<Person>.Empty;
            Parallel.ForEach(
                source: input,
                localInit: () => new List<Person>(),
                body: (p, state, local) => {
                    p.Age += 1;
                    local.Add(p);
                    return local;
                },
                local =>
                {
                    ImmutableInterlocked.Update(ref persons, l => l.AddRange(local));
                });
            return persons;
        }

        public static async Task<IList<Person>> TaskAsync(IList<Person> input)
        {
            var tasks = new List<Task<Person>>();
            foreach (var p in input)
            {
                tasks.Add(Task.Run(() => UpdateAge(p)));
            }

            return await Task.WhenAll(tasks);
        }

        private static Person UpdateAge(Person p)
        {
            p.Age += 1;
            return p;
        }
    }

To test the speed I ran a benchmark with input list sizes of 10, 100, 1.000 and 10.000.

The results are given below and on my computer the best result are to use Parallel with a local list for each process, and then in the end append lists together using a mutex (lock).

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19043.1889 (21H1/May2021Update)
Intel Core i7-8565U CPU 1.80GHz (Whiskey Lake), 1 CPU, 8 logical and 4 physical cores
.NET SDK=6.0.302
  [Host]     : .NET 6.0.7 (6.0.722.32202), X64 RyuJIT
  DefaultJob : .NET 6.0.7 (6.0.722.32202), X64 RyuJIT

The results depends on the hardware and how many parallel processes are started. You can run the benchmark yourself by running the benchmark code below on your own machine.

using BenchmarkDotNet.Attributes;

namespace Benchmark
{
    [MemoryDiagnoser]
    public class QuestionBenchmark
    {
        private IList<Person>? input;

        [Params(10, 100, 1_000, 10_000)]
        public int Size { get; set; }

        [GlobalSetup]
        public void Setup()
        {
            input = new List<Person>(Size);
            for (int i = 0; i < Size; i++)
            {
                input.Add(new Person(Age: Random.Shared.Next(10,100)));
            }
        }

        [Benchmark]
        public void PLinq()
        {
            _ = Question.PLinq(input!);
        }

        [Benchmark]
        public void ParallelForEachConcurrentBag()
        {
            _ = Question.ParallelForEachConcurrentBag(input!);
        }

        [Benchmark]
        public void ParallelForEachLock()
        {
            _ = Question.ParallelForEachLock(input!);
        }

        [Benchmark]
        public void ParallelForEachLocalInitLock()
        {
            _ = Question.ParallelForEachLocalInitLock(input!);
        }

        [Benchmark]
        public void ParallelForEachImmutable()
        {
            _ = Question.ParallelForEachImmutable(input!);
        }

        [Benchmark]
        public void ParallelForEachLocalInitImmutable()
        {
            _ = Question.ParallelForEachLocalInitImmutable(input!);
        }

        [Benchmark]
        public async Task TaskAsync()
        {
            _ = await Question.TaskAsync(input!);
        }
    }
}

I made some test to validate all solutions returns correct results - they are given below.

    public class QuestionTests
    {
        private readonly IList<Person> expected = new List<Person>()
        {
            new Person{Age=2},new Person{Age=4},new Person{Age=6}
        };
        private readonly IList<Person> input = new List<Person>()
        {
            new Person{Age=1},new Person{Age=3},new Person{Age=5}
        };

        [Fact]
        public void PLinqTest() {
            // Act
            var actual = Question.PLinq(input);

            // Assert
            Assert.True(actual.All(expected.Contains));
        }

        #region ConcurrentBag
        [Fact]
        public void ParallelForEachConcurrentBagTest()
        {
            // Act
            var actual = Question.ParallelForEachConcurrentBag(input);

            // Assert
            Assert.True(actual.All(expected.Contains));
        }
        #endregion

        #region Lock
        [Fact]
        public void ParallelForEachLockTest()
        {
            // Act
            var actual = Question.ParallelForEachLock(input);

            // Assert
            Assert.True(actual.All(expected.Contains));
        }

        [Fact]
        public void ParallelForEachLocalInitLockTest()
        {
            // Act
            var actual = Question.ParallelForEachLocalInitLock(input);

            // Assert
            Assert.True(actual.All(expected.Contains));
        }
        #endregion

        #region Immutable
        [Fact]
        public void ParallelForEachImmutableTest()
        {
            // Act
            var actual = Question.ParallelForEachImmutable(input);

            // Assert
            Assert.True(actual.All(expected.Contains));
        }

        [Fact]
        public void ParallelForEachLocalInitImmutableTest()
        {
            // Act
            var actual = Question.ParallelForEachLocalInitImmutable(input);

            // Assert
            Assert.True(actual.All(expected.Contains));
        }
        #endregion

        [Fact]
        public async Task TaskTest()
        {
            // Act
            var actual = await Question.TaskAsync(input);

            // Assert
            Assert.True(actual.All(expected.Contains));
        }
    }