Поиск…


Синтаксис

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


Modified text is an extract of the original Stack Overflow Documentation
Лицензировано согласно CC BY-SA 3.0
Не связан с Stack Overflow