Recherche…


Syntaxe

  • ParallelEnumerable.Aggregate (func)
  • ParallelEnumerable.Aggregate (graine, func)
  • ParallelEnumerable.Aggregate (seed, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
  • ParallelEnumerable.Aggregate (seedFactory, updateAccumulatorFunc, combineAccumulatorsFunc, resultSelector)
  • ParallelEnumerable.All (prédicat)
  • ParallelEnumerable.Any ()
  • ParallelEnumerable.Any (prédicat)
  • ParallelEnumerable.AsEnumerable ()
  • ParallelEnumerable.AsOrdered ()
  • ParallelEnumerable.AsParallel ()
  • ParallelEnumerable.AsSequential ()
  • ParallelEnumerable.AsUnordered ()
  • ParallelEnumerable.Average (sélecteur)
  • ParallelEnumerable.Cast ()
  • ParallelEnumerable.Concat (seconde)
  • ParallelEnumerable.Contains (valeur)
  • ParallelEnumerable.Contains (value, comparateur)
  • ParallelEnumerable.Count ()
  • ParallelEnumerable.Count (prédicat)
  • ParallelEnumerable.DefaultIfEmpty ()
  • ParallelEnumerable.DefaultIfEmpty (defaultValue)
  • ParallelEnumerable.Distinct ()
  • ParallelEnumerable.Distinct (comparateur)
  • ParallelEnumerable.ElementAt (index)
  • ParallelEnumerable.ElementAtOrDefault (index)
  • ParallelEnumerable.Empty ()
  • ParallelEnumerable.Except (second)
  • ParallelEnumerable.Except (second, comparateur)
  • ParallelEnumerable.First ()
  • ParallelEnumerable.First (prédicat)
  • ParallelEnumerable.FirstOrDefault ()
  • ParallelEnumerable.FirstOrDefault (prédicat)
  • ParallelEnumerable.ForAll (action)
  • ParallelEnumerable.GroupBy (keySelector)
  • ParallelEnumerable.GroupBy (keySelector, comparateur)
  • ParallelEnumerable.GroupBy (keySelector, elementSelector)
  • ParallelEnumerable.GroupBy (keySelector, elementSelector, comparateur)
  • ParallelEnumerable.GroupBy (keySelector, resultSelector)
  • ParallelEnumerable.GroupBy (keySelector, resultSelector, comparateur)
  • ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector)
  • ParallelEnumerable.GroupBy (keySelector, elementSelector, ruleSelector, comparateur)
  • ParallelEnumerable.GroupJoin (inner, outerKeySelector, innerKeySelector, resultSelector)
  • ParallelEnumerable.GroupJoin (interne, outerKeySelector, innerKeySelector, resultSelector, comparateur)
  • ParallelEnumerable.Intersect (second)
  • ParallelEnumerable.Intersect (second, comparateur)
  • ParallelEnumerable.Join (interne, outerKeySelector, innerKeySelector, resultSelector)
  • ParallelEnumerable.Join (interne, outerKeySelector, innerKeySelector, resultSelector, comparateur)
  • ParallelEnumerable.Last ()
  • ParallelEnumerable.Last (prédicat)
  • ParallelEnumerable.LastOrDefault ()
  • ParallelEnumerable.LastOrDefault (prédicat)
  • ParallelEnumerable.LongCount ()
  • ParallelEnumerable.LongCount (prédicat)
  • ParallelEnumerable.Max ()
  • ParallelEnumerable.Max (sélecteur)
  • ParallelEnumerable.Min ()
  • ParallelEnumerable.Min (sélecteur)
  • ParallelEnumerable.OfType ()
  • ParallelEnumerable.OrderBy (keySelector)
  • ParallelEnumerable.OrderBy (keySelector, comparateur)
  • ParallelEnumerable.OrderByDescending (keySelector)
  • ParallelEnumerable.OrderByDescending (keySelector, comparateur)
  • ParallelEnumerable.Range (démarrer, compter)
  • ParallelEnumerable.Repeat (élément, nombre)
  • ParallelEnumerable.Reverse ()
  • ParallelEnumerable.Select (sélecteur)
  • ParallelEnumerable.SelectMany (sélecteur)
  • ParallelEnumerable.SelectMany (collectionSelector, resultSelector)
  • ParallelEnumerable.SequenceEqual (second)
  • ParallelEnumerable.SequenceEqual (second, comparateur)
  • ParallelEnumerable.Single ()
  • ParallelEnumerable.Single (prédicat)
  • ParallelEnumerable.SingleOrDefault ()
  • ParallelEnumerable.SingleOrDefault (prédicat)
  • ParallelEnumerable.Skip (count)
  • ParallelEnumerable.SkipWhile (prédicat)
  • ParallelEnumerable.Sum ()
  • ParallelEnumerable.Sum (sélecteur)
  • ParallelEnumerable.Take (count)
  • ParallelEnumerable.TakeWhile (prédicat)
  • ParallelEnumerable.ThenBy (keySelector)
  • ParallelEnumerable.ThenBy (keySelector, comparateur)
  • ParallelEnumerable.ThenByDescending (keySelector)
  • ParallelEnumerable.ThenByDescending (keySelector, comparateur)
  • ParallelEnumerable.ToArray ()
  • ParallelEnumerable.ToDictionary (keySelector)
  • ParallelEnumerable.ToDictionary (keySelector, comparateur)
  • ParallelEnumerable.ToDictionary (elementSelector)
  • ParallelEnumerable.ToDictionary (elementSelector, comparateur)
  • ParallelEnumerable.ToList ()
  • ParallelEnumerable.ToLookup (keySelector)
  • ParallelEnumerable.ToLookup (keySelector, comparateur)
  • ParallelEnumerable.ToLookup (keySelector, elementSelector)
  • ParallelEnumerable.ToLookup (keySelector, elementSelector, comparateur)
  • ParallelEnumerable.Union (second)
  • ParallelEnumerable.Union (second, comparateur)
  • ParallelEnumerable.Where (prédicat)
  • ParallelEnumerable.WithCancellation (annulationToken)
  • ParallelEnumerable.WithDegreeOfParallelism (degreeOfParallelism)
  • ParallelEnumerable.WithExecutionMode (mode d'exécution)
  • ParallelEnumerable.WithMergeOptions (mergeOptions)
  • ParallelEnumerable.Zip (second, resultSelector)

Exemple simple

Cet exemple montre comment PLINQ peut être utilisé pour calculer les nombres pairs compris entre 1 et 10 000 en utilisant plusieurs threads. Notez que la liste ne sera pas commandée!

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

Le degré de parallélisme correspond au nombre maximal de tâches exécutées simultanément qui seront utilisées pour traiter la requête.

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

AsOrdered

Cet exemple montre comment PLINQ peut être utilisé pour calculer les nombres pairs compris entre 1 et 10 000 en utilisant plusieurs threads. L'ordre sera maintenu dans la liste résultante, mais gardez à l'esprit AsOrdered peut nuire aux performances d'un grand nombre d'éléments, de sorte que le traitement non ordonné est préférable lorsque cela est possible.

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

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

Comme unordorded

Les séquences ordonnées peuvent nuire aux performances lorsque vous manipulez un grand nombre d'éléments. Pour atténuer ce AsUnordered , il est possible d'appeler AsUnordered lorsque l'ordre des séquences n'est plus nécessaire.

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
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow