C# Language
병렬 LINQ (PLINQ)

통사론

• ParallelEnumerable.Aggregate (func)
• ParallelEnumerable.Aggregate (seed, func)
• ParallelEnumerable.Aggregate (seed, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
• ParallelEnumerable.Aggregate (seedFactory, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
• ParallelEnumerable.All (술어)
• ParallelEnumerable.Any ()
• ParallelEnumerable.Any (술어)
• ParallelEnumerable.AsEnumerable ()
• ParallelEnumerable.AsOrdered ()
• ParallelEnumerable.AsParallel ()
• ParallelEnumerable.AsSequential ()
• Asynchronous 된 ()
• ParallelEnumerable.Average (선택기)
• ParallelEnumerable.Cast ()
• ParallelEnumerable.Concat (second)
• ParallelEnumerable.Contains (value)
• ParallelEnumerable.Contains (value, comparer)
• ParallelEnumerable.Count ()
• ParallelEnumerable.Count (조건 자)
• ParallelEnumerable.DefaultIfEmpty ()
• ParallelEnumerable.DefaultIfEmpty (defaultValue)
• ParallelEnumerable.Distinct ()
• ParallelEnumerable.Distinct (비교 자)
• ParallelEnumerable.ElementAt (index)
• ParallelEnumerable.ElementAtOrDefault (index)
• ParallelEnumerable.Empty ()
• ParallelEnumerable.Except (초)
• ParallelEnumerable.Except (second, comparer)
• 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)
• GroupJoin (inner, outerKeySelector, innerKeySelector, resultSelector)
• GroupJoin (inner, outerKeySelector, 내부 키 선택기, 결과 선택기, 비교 자)
• ParallelEnumerable.Intersect (초)
• ParallelEnumerable.Intersect (second, comparer)
• ParallelEnumerable.Join (inner, outerKeySelector, innerKeySelector, resultSelector)
• ParallelEnumerable.Join (inner, outerKeySelector, 내부 키 선택기, 결과 선택기, 비교 자)
• 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 (selector)
• ParallelEnumerable.SelectMany (selector)
• ParallelEnumerable.SelectMany (collectionSelector, resultSelector)
• ParallelEnumerable.SequenceEqual (second)
• ParallelEnumerable.SequenceEqual (두 번째, 비교 자)
• ParallelEnumerable.Single ()
• ParallelEnumerable.Single (조건부)
• ParallelEnumerable.SingleOrDefault ()
• ParallelEnumerable.SingleOrDefault (조건 자)
• ParallelEnumerable.Skip (count)
• ParallelEnumerable.SkipWhile (조건부)
• ParallelEnumerable.Sum ()
• ParallelEnumerable.Sum (선택기)
• ParallelEnumerable.Take (count)
• 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 (second, comparer)
• ParallelEnumerable. Where (조건부)
• ParallelEnumerable.WithCancellation (cancellationToken)
• ParallelEnumerable.WithDegreeOfParallelism (degreeOfParallelism)
• ParallelEnumerable.WithExecutionMode (executionMode)
• ParallelEnumerable.WithMergeOptions (mergeOptions)
• ParallelEnumerable.Zip (second, resultSelector)

간단한 예

이 예에서는 PLINQ를 사용하여 여러 스레드를 사용하여 1에서 10,000 사이의 짝수를 계산하는 방법을 보여줍니다. 결과 목록은 주문되지 않습니다.

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에서 10,000 사이의 짝수를 계산하는 방법을 보여줍니다. 결과 목록에서 순서가 유지되지만 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();