수색…


통사론

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


Modified text is an extract of the original Stack Overflow Documentation
아래 라이선스 CC BY-SA 3.0
와 제휴하지 않음 Stack Overflow