C# Language
Параллельный LINQ (PLINQ)

Синтаксис

• ParallelEnumerable.Aggregate (FUNC)
• ParallelEnumerable.Aggregate (seed, func)
• ParallelEnumerable.Aggregate (seed, updateAccumulatorFunc, combAccumulatorsFunc, resultSelector)
• ParallelEnumerable.Aggregate (seedFactory, updateAccumulatorFunc, combAccumulatorsFunc, resultSelector)
• ParallelEnumerable.All (предикат)
• ParallelEnumerable.Any ()
• ParallelEnumerable.Any (предикат)
• ParallelEnumerable.AsEnumerable ()
• ParallelEnumerable.AsOrdered ()
• ParallelEnumerable.AsParallel ()
• ParallelEnumerable.AsSequential ()
• ParallelEnumerable.AsUnordered ()
• ParallelEnumerable.Average (селектор)
• ParallelEnumerable.Cast ()
• ParallelEnumerable.Concat (второй)
• ParallelEnumerable.Contains (значение)
• ParallelEnumerable.Contains (значение, сравнение)
• ParallelEnumerable.Count ()
• ParallelEnumerable.Count (предикат)
• ParallelEnumerable.DefaultIfEmpty ()
• ParallelEnumerable.DefaultIfEmpty (DefaultValue)
• ParallelEnumerable.Distinct ()
• ParallelEnumerable.Distinct (Comparer)
• ParallelEnumerable.ElementAt (индекс)
• ParallelEnumerable.ElementAtOrDefault (индекс)
• ParallelEnumerable.Empty ()
• ParallelEnumerable.Except (второй)
• ParallelEnumerable.Except (во-вторых, сравнение)
• ParallelEnumerable.First ()
• ParallelEnumerable.First (предикат)
• ParallelEnumerable.FirstOrDefault ()
• ParallelEnumerable.FirstOrDefault (предикат)
• ParallelEnumerable.ForAll (действие)
• 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 (внутренний, внешнийKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.GroupJoin (внутренний, внешнийKeySelector, innerKeySelector, resultSelector, comparer)
• ParallelEnumerable.Intersect (второй)
• ParallelEnumerable.Intersect (второй, сравнительный)
• ParallelEnumerable.Join (внутренний, внешнийKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.Join (внутренний, внешнийKeySelector, innerKeySelector, resultSelector, comparer)
• ParallelEnumerable.Last ()
• ParallelEnumerable.Last (предикат)
• ParallelEnumerable.LastOrDefault ()
• ParallelEnumerable.LastOrDefault (предикат)
• ParallelEnumerable.LongCount ()
• ParallelEnumerable.LongCount (предикат)
• ParallelEnumerable.Max ()
• ParallelEnumerable.Max (селектор)
• ParallelEnumerable.Min ()
• ParallelEnumerable.Min (селектор)
• ParallelEnumerable.OfType ()
• ParallelEnumerable.OrderBy (keySelector)
• ParallelEnumerable.OrderBy (keySelector, comparer)
• ParallelEnumerable.OrderByDescending (keySelector)
• ParallelEnumerable.OrderByDescending (keySelector, comparer)
• ParallelEnumerable.Range (начало, количество)
• ParallelEnumerable.Repeat (элемент, счетчик)
• ParallelEnumerable.Reverse ()
• ParallelEnumerable.Select (селектор)
• ParallelEnumerable.SelectMany (селектор)
• ParallelEnumerable.SelectMany (collectionSelector, resultSelector)
• ParallelEnumerable.SequenceEqual (второй)
• ParallelEnumerable.SequenceEqual (второй, сравнительный)
• ParallelEnumerable.Single ()
• ParallelEnumerable.Single (предикат)
• ParallelEnumerable.SingleOrDefault ()
• ParallelEnumerable.SingleOrDefault (предикат)
• ParallelEnumerable.Skip (количество)
• ParallelEnumerable.SkipWhile (предикат)
• ParallelEnumerable.Sum ()
• ParallelEnumerable.Sum (селектор)
• ParallelEnumerable.Take (количество)
• ParallelEnumerable.TakeWhile (предикат)
• 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 (второй)
• ParallelEnumerable.Union (второй, сравнительный)
• ParallelEnumerable.Where (предикат)
• ParallelEnumerable.WithCancellation (CancellationToken)
• ParallelEnumerable.WithDegreeOfParallelism (degreeOfParallelism)
• ParallelEnumerable.WithExecutionMode (executionMode)
• ParallelEnumerable.WithMergeOptions (mergeOptions)
• ParallelEnumerable.Zip (второй, resultSelector)

Простой пример

В этом примере показано, как PLINQ может использоваться для вычисления четных чисел от 1 до 10000 с использованием нескольких потоков. Обратите внимание, что результирующий список не будет заказан!

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

WithDegreeOfParallelism

Степень параллелизма - это максимальное количество одновременно выполняемых задач, которые будут использоваться для обработки запроса.

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

AsOrdered

В этом примере показано, как PLINQ может использоваться для вычисления четных чисел от 1 до 10000 с использованием нескольких потоков. Заказ будет сохранен в результирующем списке, однако имейте в виду, что AsOrdered может повредить производительность для большого количества элементов, поэтому AsOrdered обработка является предпочтительной, когда это возможно.

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

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

AsUnordered

Упорядоченные последовательности могут повредить производительность при работе с большим количеством элементов. Чтобы смягчить это, можно вызвать AsUnordered когда порядок последовательности больше не нужен.

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();