Common operations like map and filter are available in parallelized form through PLINQ, though the names differ. A map can be achieved with PLINQ’s Select operator, and a filter with PLINQ’s Where operator.<\/p>\n
For example, I could implement a ParallelMap operation that takes in one array and returns another as follows:<\/p>\n
\npublic static TOutput [] ParallelMap<TInput,TOutput>(
TInput [] input, Func<TInput,TOutput> map)
{
return input.AsParallel().Select(map).ToArray();
}<\/p>\n<\/blockquote>\nand a ParallelFilter operation could be implemented in a similar fashion, based on PLINQ’s Where operator:<\/p>\n
\npublic static TInput [] ParallelFilter<TInput>(
TInput [] input, Func<TInput,Boolean> filter)
{
return input.AsParallel().Where(filter).ToArray();
}<\/p>\n<\/blockquote>\nIn general, PLINQ is the recommended way to achieve such parallelization. Not only is it useful for individual operations like this, but it’s also a great way to compose operations. For example, if I wanted to write a ParallelFilterAndMap, I could achieve that as follows:<\/p>\n
\npublic static TOutput [] ParallelFilterAndMap<TInput,TOutput>(
TInput [] input, Func<TInput,Boolean> filter, Func<TInput,TOutput> map)
{
return input.AsParallel().Where(filter).Select(map).ToArray();
}<\/p>\n<\/blockquote>\nIt is also possible to build such operations on top of Parallel.*. For example, here’s ParallelMap re-implemented in terms of Parallel.For:<\/p>\n
\npublic static TOutput [] ParallelMap<TInput,TOutput>(
TInput [] input, Func<TInput,TOutput> map)
{
var output = new TOutput[input.Length];
Parallel.For(0, input.Length, i => output[i] = map(input[i]));
return output;
}<\/p>\n<\/blockquote>\nand ParallelFilterAndMap re-implemented in terms of Parallel.ForEach and ConcurrentBag<T>:<\/p>\n
\npublic static TInput [] ParallelFilterAndMap<TInput,TOutput>(
TInput [] input, Func<TInput,Boolean> filter, Func<TInput,TOutput> map)
{
var output = new ConcurrentBag<T>();
Parallel.ForEach(input, item =>
{
if (filter(item)) output.Add(map(item));
});
return output.ToArray();
}<\/p>\n<\/blockquote>\nAs mentioned, in most cases you’re better off using PLINQ for these kinds of operations. However, there may be cases where a Parallel.*-based version is best. For example, let’s say that you wanted to implement an in-place parallel map operation, e.g. a map operation that maps from TData to TData, and that stores the new output into the input array. PLINQ doesn’t modify the input data source, so if you wanted that functionality, you could build it on top of Parallel.For:<\/p>\n
\npublic static void ParallelMap<TData>(
TData [] data, Func<TData,TData> map)
{
Parallel.For(0, data.Length, i => data[i] = map(data[i]));
}<\/p>\n<\/blockquote>\nThere are a few other subtle differences that you could take advantage of by building on Parallel.For\/ForEach instead of on PLINQ. For example, PLINQ uses a static number of threads for the processing of a given query (which defaults to Environment.ProcessorCount), whereas the number of threads used by Parallel.* may vary over time as influenced by the ThreadPool’s thread injection and retirement logic. Parallel.* can also be targeted to a specific and custom TaskScheduler, something not supported by PLINQ in .NET 4 (PLINQ always runs on TaskScheduler.Default, which is based on the .NET 4 ThreadPool).<\/p>\n
Happy coding.<\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
Common operations like map and filter are available in parallelized form through PLINQ, though the names differ. A map can be achieved with PLINQ’s Select operator, and a filter with PLINQ’s Where operator. For example, I could implement a ParallelMap operation that takes in one array and returns another as follows: public static TOutput [] […]<\/p>\n","protected":false},"author":360,"featured_media":58792,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[7908],"tags":[7907,7911,7909,7910,7912],"class_list":["post-55975","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-pfxteam","tag-net-4","tag-code-samples","tag-parallel-extensions","tag-plinq","tag-task-parallel-library"],"acf":[],"blog_post_summary":"
Common operations like map and filter are available in parallelized form through PLINQ, though the names differ. A map can be achieved with PLINQ’s Select operator, and a filter with PLINQ’s Where operator. For example, I could implement a ParallelMap operation that takes in one array and returns another as follows: public static TOutput [] […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/55975","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/360"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=55975"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/55975\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/58792"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=55975"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=55975"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=55975"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}