Parallel LINQ (PLINQ)

Syntax

  • ParallelEnumerable.Aggregate(func)
  • ParallelEnumerable.Aggregate(seed, func)
  • ParallelEnumerable.Aggregate(seed, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
  • ParallelEnumerable.Aggregate(seedFactory, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
  • ParallelEnumerable.All(predicate)
  • ParallelEnumerable.Any()
  • ParallelEnumerable.Any(predicate)
  • ParallelEnumerable.AsEnumerable()
  • ParallelEnumerable.AsOrdered()
  • ParallelEnumerable.AsParallel()
  • ParallelEnumerable.AsSequential()
  • ParallelEnumerable.AsUnordered()
  • ParallelEnumerable.Average(selector)
  • ParallelEnumerable.Cast()
  • ParallelEnumerable.Concat(second)
  • ParallelEnumerable.Contains(value)
  • ParallelEnumerable.Contains(value, comparer)
  • ParallelEnumerable.Count()
  • ParallelEnumerable.Count(predicate)
  • ParallelEnumerable.DefaultIfEmpty()
  • ParallelEnumerable.DefaultIfEmpty(defaultValue)
  • ParallelEnumerable.Distinct()
  • ParallelEnumerable.Distinct(comparer)
  • ParallelEnumerable.ElementAt(index)
  • ParallelEnumerable.ElementAtOrDefault(index)
  • ParallelEnumerable.Empty()
  • ParallelEnumerable.Except(second)
  • ParallelEnumerable.Except(second, comparer)
  • ParallelEnumerable.First()
  • ParallelEnumerable.First(predicate)
  • ParallelEnumerable.FirstOrDefault()
  • ParallelEnumerable.FirstOrDefault(predicate)
  • ParallelEnumerable.ForAll(action)
  • ParallelEnumerable.GroupBy(keySelector)
  • ParallelEnumerable.GroupBy(keySelector, comparer)
  • ParallelEnumerable.GroupBy(keySelector, elementSelector)
  • ParallelEnumerable.GroupBy(keySelector, elementSelector, comparer)
  • ParallelEnumerable.GroupBy(keySelector, resultSelector)
  • ParallelEnumerable.GroupBy(keySelector, resultSelector, comparer)
  • ParallelEnumerable.GroupBy(keySelector, elementSelector, ruleSelector)
  • ParallelEnumerable.GroupBy(keySelector, elementSelector, ruleSelector, comparer)
  • ParallelEnumerable.GroupJoin(inner, outerKeySelector, innerKeySelector, resultSelector)
  • ParallelEnumerable.GroupJoin(inner, outerKeySelector, innerKeySelector, resultSelector, comparer)
  • ParallelEnumerable.Intersect(second)
  • ParallelEnumerable.Intersect(second, comparer)
  • ParallelEnumerable.Join(inner, outerKeySelector, innerKeySelector, resultSelector)
  • ParallelEnumerable.Join(inner, outerKeySelector, innerKeySelector, resultSelector, comparer)
  • ParallelEnumerable.Last()
  • ParallelEnumerable.Last(predicate)
  • ParallelEnumerable.LastOrDefault()
  • ParallelEnumerable.LastOrDefault(predicate)
  • ParallelEnumerable.LongCount()
  • ParallelEnumerable.LongCount(predicate)
  • ParallelEnumerable.Max()
  • ParallelEnumerable.Max(selector)
  • ParallelEnumerable.Min()
  • ParallelEnumerable.Min(selector)
  • ParallelEnumerable.OfType()
  • ParallelEnumerable.OrderBy(keySelector)
  • ParallelEnumerable.OrderBy(keySelector, comparer)
  • ParallelEnumerable.OrderByDescending(keySelector)
  • ParallelEnumerable.OrderByDescending(keySelector, comparer)
  • ParallelEnumerable.Range(start, count)
  • ParallelEnumerable.Repeat(element, count)
  • ParallelEnumerable.Reverse()
  • ParallelEnumerable.Select(selector)
  • ParallelEnumerable.SelectMany(selector)
  • ParallelEnumerable.SelectMany(collectionSelector, resultSelector)
  • ParallelEnumerable.SequenceEqual(second)
  • ParallelEnumerable.SequenceEqual(second, comparer)
  • ParallelEnumerable.Single()
  • ParallelEnumerable.Single(predicate)
  • ParallelEnumerable.SingleOrDefault()
  • ParallelEnumerable.SingleOrDefault(predicate)
  • ParallelEnumerable.Skip(count)
  • ParallelEnumerable.SkipWhile(predicate)
  • ParallelEnumerable.Sum()
  • ParallelEnumerable.Sum(selector)
  • ParallelEnumerable.Take(count)
  • ParallelEnumerable.TakeWhile(predicate)
  • ParallelEnumerable.ThenBy(keySelector)
  • ParallelEnumerable.ThenBy(keySelector, comparer)
  • ParallelEnumerable.ThenByDescending(keySelector)
  • ParallelEnumerable.ThenByDescending(keySelector, comparer)
  • ParallelEnumerable.ToArray()
  • ParallelEnumerable.ToDictionary(keySelector)
  • ParallelEnumerable.ToDictionary(keySelector, comparer)
  • ParallelEnumerable.ToDictionary(elementSelector)
  • ParallelEnumerable.ToDictionary(elementSelector, comparer)
  • ParallelEnumerable.ToList()
  • ParallelEnumerable.ToLookup(keySelector)
  • ParallelEnumerable.ToLookup(keySelector, comparer)
  • ParallelEnumerable.ToLookup(keySelector, elementSelector)
  • ParallelEnumerable.ToLookup(keySelector, elementSelector, comparer)
  • ParallelEnumerable.Union(second)
  • ParallelEnumerable.Union(second, comparer)
  • ParallelEnumerable.Where(predicate)
  • ParallelEnumerable.WithCancellation(cancellationToken)
  • ParallelEnumerable.WithDegreeOfParallelism(degreeOfParallelism)
  • ParallelEnumerable.WithExecutionMode(executionMode)
  • ParallelEnumerable.WithMergeOptions(mergeOptions)
  • ParallelEnumerable.Zip(second, resultSelector)

Simple example

This example shows how PLINQ can be used to calculate the even numbers between 1 and 10,000 using multiple threads. Note that the resulting list will won't be ordered!

var sequence = Enumerable.Range(1, 10000);
var evenNumbers = sequence.AsParallel()
                          .Where(x => x % 2 == 0)
                          .ToList();

// evenNumbers = { 4, 26, 28, 30, ... }
// Order will vary with different runs

AsOrdered

This example shows how PLINQ can be used to calculate the even numbers between 1 and 10,000 using multiple threads. Order will be maintained in the resulting list, however keep in mind that AsOrdered may hurt performance for a large numbers of elements, so un-ordered processing is preferred when possible.

var sequence = Enumerable.Range(1, 10000);
var evenNumbers = sequence.AsParallel()
                          .AsOrdered()
                          .Where(x => x % 2 == 0)
                          .ToList();

// evenNumbers = { 2, 4, 6, 8, ..., 10000 }

AsUnordered

Ordered sequences may hurt performance when dealing with a large number of elements. To mitigate this, it's possible to call AsUnordered when the sequence order is no longer necessary.

var sequence = Enumerable.Range(1, 10000).Select(x => -1 * x); // -1, -2, ...
var evenNumbers = sequence.AsParallel()
                          .OrderBy(x => x)
                          .Take(5000)
                          .AsUnordered()
                          .Where(x => x % 2 == 0) // This line won't be affected by ordering
                          .ToList();

WithDegreeOfParallelism

The degree of parallelism is the maximum number of concurrently executing tasks that will be used to process the query.

var sequence = Enumerable.Range(1, 10000);
var evenNumbers = sequence.AsParallel()
                          .WithDegreeOfParallelism(4)
                          .Where(x => x % 2 == 0);