Introduction à PLINQIntroduction to PLINQ

Parallel LINQ (PLINQ) est une implémentation parallèle du modèle LINQ (Language-Integrated Query) .Parallel LINQ (PLINQ) is a parallel implementation of the Language-Integrated Query (LINQ) pattern. PLINQ implémente le jeu complet d’opérateurs de requête standard LINQ comme méthodes d’extension pour l’espace de noms System.Linq et inclut des opérateurs supplémentaires pour les opérations parallèles.PLINQ implements the full set of LINQ standard query operators as extension methods for the System.Linq namespace and has additional operators for parallel operations. PLINQ combine la simplicité et la lisibilité de la syntaxe LINQ à la puissance de la programmation parallèle.PLINQ combines the simplicity and readability of LINQ syntax with the power of parallel programming.

Conseil

Si vous n’êtes pas familiarisé avec LINQ, il comprend un modèle unifié pour interroger une source de données énumérable de façon sécurisée.If you're not familiar with LINQ, it features a unified model for querying any enumerable data source in a type-safe manner. LINQ to Objects est le nom des requêtes LINQ exécutées sur les collections en mémoire telles que List<T> et les tableaux.LINQ to Objects is the name for LINQ queries that are run against in-memory collections such as List<T> and arrays. Cet article suppose que vous avez une connaissance de base de LINQ.This article assumes that you have a basic understanding of LINQ. Pour plus d’informations, consultez LINQ (Language-Integrated Query).For more information, see Language-Integrated Query (LINQ).

Qu’est-ce qu’une requête parallèle ?What is a Parallel query?

Une requête PLINQ ressemble à bien des égards à une requête LINQ to Objects non parallèle.A PLINQ query in many ways resembles a non-parallel LINQ to Objects query. Les requêtes PLINQ, tout comme les requêtes LINQ séquentielles, fonctionnent sur n’importe quelle IEnumerable source de données ou mémoire IEnumerable<T> , et ont une exécution différée, ce qui signifie qu’elles ne commencent pas à s’exécuter tant que la requête n’est pas énumérée.PLINQ queries, just like sequential LINQ queries, operate on any in-memory IEnumerable or IEnumerable<T> data source, and have deferred execution, which means they do not begin executing until the query is enumerated. La principale différence est que PLINQ essaie d’utiliser pleinement tous les processeurs sur le système.The primary difference is that PLINQ attempts to make full use of all the processors on the system. Cela s’effectue par le partitionnement de la source de données en segments et l’exécution de la requête sur chaque segment sur des threads de travail distincts en parallèle sur plusieurs processeurs.It does this by partitioning the data source into segments, and then executing the query on each segment on separate worker threads in parallel on multiple processors. Dans de nombreux cas, l’exécution parallèle signifie une exécution beaucoup plus rapide de la requête.In many cases, parallel execution means that the query runs significantly faster.

L’exécution parallèle permet à PLINQ d’améliorer de manière significative les performances du code hérité pour certains types de requêtes, souvent par le simple ajout de l’opération de requête AsParallel à la source de données.Through parallel execution, PLINQ can achieve significant performance improvements over legacy code for certain kinds of queries, often just by adding the AsParallel query operation to the data source. Toutefois, le parallélisme peut présenter ses propres complexités et toutes les opérations de requête ne s’exécutent pas plus rapidement dans PLINQ.However, parallelism can introduce its own complexities, and not all query operations run faster in PLINQ. En fait, la parallélisation ralentit réellement certaines requêtes.In fact, parallelization actually slows down certain queries. Par conséquent, vous devez comprendre comment des problèmes, tels que ceux liés à l’ordre, affectent les requêtes parallèles.Therefore, you should understand how issues such as ordering affect parallel queries. Pour plus d’informations, consultez Fonctionnement de l’accélération dans PLINQ.For more information, see Understanding Speedup in PLINQ.

Notes

Cette documentation utilise des expressions lambda pour définir les délégués en PLINQ.This documentation uses lambda expressions to define delegates in PLINQ. Si les expressions lambda en C# ou Visual Basic ne vous sont pas familières, consultez la page Expressions lambda en PLINQ et dans la bibliothèque parallèle de tâches.If you are not familiar with lambda expressions in C# or Visual Basic, see Lambda Expressions in PLINQ and TPL.

Le reste de cet article donne une vue d’ensemble des principales classes PLINQ et explique comment créer des requêtes PLINQ.The remainder of this article gives an overview of the main PLINQ classes and discusses how to create PLINQ queries. Chaque section contient des liens vers des exemples de code et des informations plus détaillées.Each section contains links to more detailed information and code examples.

Classe ParallelEnumerableThe ParallelEnumerable Class

La classe System.Linq.ParallelEnumerable expose presque toutes les fonctionnalités de PLINQ.The System.Linq.ParallelEnumerable class exposes almost all of PLINQ's functionality. Celle-ci et le reste des types d’espaces de noms System.Linq sont compilés dans l’assembly System.Core.dll.It and the rest of the System.Linq namespace types are compiled into the System.Core.dll assembly. Les projets C# et Visual Basic par défaut de Visual Studio font tous deux référence à l’assembly et importent l’espace de noms.The default C# and Visual Basic projects in Visual Studio both reference the assembly and import the namespace.

ParallelEnumerable inclut les implémentations de tous les opérateurs de requête standard pris en charge par LINQ to Objects, bien qu’il ne tente pas de paralléliser chacun d’eux.ParallelEnumerable includes implementations of all the standard query operators that LINQ to Objects supports, although it does not attempt to parallelize each one. Si vous n’êtes pas familiarisé avec LINQ, consultez Introduction à LINQ (C#) et Introduction à LINQ (Visual Basic).If you are not familiar with LINQ, see Introduction to LINQ (C#) and Introduction to LINQ (Visual Basic).

Outre les opérateurs de requête standard, la classe ParallelEnumerable contient un ensemble de méthodes qui activent des comportements spécifiques à l’exécution parallèle.In addition to the standard query operators, the ParallelEnumerable class contains a set of methods that enable behaviors specific to parallel execution. Ces méthodes spécifiques de PLINQ sont répertoriées dans le tableau suivant.These PLINQ-specific methods are listed in the following table.

Opérateur ParallelEnumerableParallelEnumerable Operator DescriptionDescription
AsParallel Point d’entrée de PLINQ.The entry point for PLINQ. Indique que le reste de la requête doit être parallélisé, si possible.Specifies that the rest of the query should be parallelized, if it is possible.
AsSequential Indique que le reste de la requête doit être exécuté de manière séquentielle, comme requête LINQ non parallèle.Specifies that the rest of the query should be run sequentially, as a non-parallel LINQ query.
AsOrdered Indique que PLINQ doit conserver l’ordre de la séquence source pour le reste de la requête, ou jusqu’à ce que l’ordre soit modifié, par exemple à l’aide d’une clause orderby (Order By en Visual Basic).Specifies that PLINQ should preserve the ordering of the source sequence for the rest of the query, or until the ordering is changed, for example by the use of an orderby (Order By in Visual Basic) clause.
AsUnordered Indique que PLINQ ne doit pas conserver l’ordre de la séquence source pour le reste de la requête.Specifies that PLINQ for the rest of the query is not required to preserve the ordering of the source sequence.
WithCancellation Indique que PLINQ doit régulièrement surveiller l’état du jeton d’annulation fourni et annuler l’exécution si cela est demandé.Specifies that PLINQ should periodically monitor the state of the provided cancellation token and cancel execution if it is requested.
WithDegreeOfParallelism Spécifie le nombre maximal de processeurs que PLINQ doit utiliser pour paralléliser la requête.Specifies the maximum number of processors that PLINQ should use to parallelize the query.
WithMergeOptions Fournit une indication sur la manière dont PLINQ doit, si possible, fusionner les résultats parallèles en une seule séquence sur le thread utilisé.Provides a hint about how PLINQ should, if it is possible, merge parallel results back into just one sequence on the consuming thread.
WithExecutionMode Indique si PLINQ doit paralléliser la requête même si le comportement par défaut consisterait à l’exécuter de manière séquentielle.Specifies whether PLINQ should parallelize the query even when the default behavior would be to run it sequentially.
ForAll Méthode d’énumération multithread qui, contrairement à l’itération sur les résultats de la requête, permet leur traitement en parallèle sans nécessiter la fusion préalable dans le thread utilisé.A multithreaded enumeration method that, unlike iterating over the results of the query, enables results to be processed in parallel without first merging back to the consumer thread.
Aggregate surchargeAggregate overload Surcharge propre à PLINQ qui permet l’agrégation intermédiaire sur des partitions locales des threads,et fonction d’agrégation finale permettant de combiner les résultats de toutes les partitions.An overload that is unique to PLINQ and enables intermediate aggregation over thread-local partitions, plus a final aggregation function to combine the results of all partitions.

Modèle Opt-inThe Opt-in Model

Lorsque vous écrivez une requête, utilisez PLINQ en appelant la méthode d’extension ParallelEnumerable.AsParallel sur la source de données, comme illustré dans l’exemple suivant.When you write a query, opt in to PLINQ by invoking the ParallelEnumerable.AsParallel extension method on the data source, as shown in the following example.

var source = Enumerable.Range(1, 10000);

// Opt in to PLINQ with AsParallel.
var evenNums = from num in source.AsParallel()
               where num % 2 == 0
               select num;
Console.WriteLine("{0} even numbers out of {1} total",
                  evenNums.Count(), source.Count());
// The example displays the following output:
//       5000 even numbers out of 10000 total
Dim source = Enumerable.Range(1, 10000)

' Opt in to PLINQ with AsParallel
Dim evenNums = From num In source.AsParallel()
               Where num Mod 2 = 0
               Select num
Console.WriteLine("{0} even numbers out of {1} total",
                  evenNums.Count(), source.Count())
' The example displays the following output:
'       5000 even numbers out of 10000 total      

La méthode d’extension AsParallel lie les opérateurs de requête suivants, dans ce cas, where et select, aux implémentations System.Linq.ParallelEnumerable.The AsParallel extension method binds the subsequent query operators, in this case, where and select, to the System.Linq.ParallelEnumerable implementations.

Modes d’exécutionExecution Modes

Par défaut, PLINQ est conservateur.By default, PLINQ is conservative. Au moment de l’exécution, l’infrastructure PLINQ analyse la structure globale de la requête.At run time, the PLINQ infrastructure analyzes the overall structure of the query. Si la requête est susceptible de produire des accélérations par parallélisation, PLINQ partitionne la séquence source en tâches pouvant être exécutées simultanément.If the query is likely to yield speedups by parallelization, PLINQ partitions the source sequence into tasks that can be run concurrently. Si la parallélisation d’une requête présente un risque, PLINQ exécute uniquement la requête de manière séquentielle.If it is not safe to parallelize a query, PLINQ just runs the query sequentially. Si PLINQ a le choix entre un algorithme parallèle potentiellement coûteux ou un algorithme séquentiel abordable, il choisit l’algorithme séquentiel par défaut.If PLINQ has a choice between a potentially expensive parallel algorithm or an inexpensive sequential algorithm, it chooses the sequential algorithm by default. Vous pouvez utiliser la méthode WithExecutionMode et l’énumération System.Linq.ParallelExecutionMode pour indiquer à PLINQ de sélectionner l’algorithme parallèle.You can use the WithExecutionMode method and the System.Linq.ParallelExecutionMode enumeration to instruct PLINQ to select the parallel algorithm. Cela est utile lorsque vous savez suite à des tests ou des mesures qu’une requête spécifique s’exécute plus rapidement en parallèle.This is useful when you know by testing and measurement that a particular query executes faster in parallel. Pour plus d’informations, consultez How to: Specify the Execution Mode in PLINQ (Guide pratique pour spécifier le mode d’exécution dans PLINQ).For more information, see How to: Specify the Execution Mode in PLINQ.

Degré de parallélismeDegree of Parallelism

Par défaut, PLINQ utilise tous les processeurs de l’ordinateur hôte.By default, PLINQ uses all of the processors on the host computer. Vous pouvez demander à PLINQ de ne pas utiliser plus d’un nombre spécifié de processeurs à l’aide de la méthode WithDegreeOfParallelism.You can instruct PLINQ to use no more than a specified number of processors by using the WithDegreeOfParallelism method. Cela est utile lorsque vous souhaitez vous assurer que les autres processus en cours d’exécution sur l’ordinateur reçoivent une certaine quantité de temps CPU.This is useful when you want to make sure that other processes running on the computer receive a certain amount of CPU time. L’extrait suivant limite la requête à l’utilisation de deux processeurs maximum.The following snippet limits the query to utilizing a maximum of two processors.

var query = from item in source.AsParallel().WithDegreeOfParallelism(2)
            where Compute(item) > 42
            select item;
Dim query = From item In source.AsParallel().WithDegreeOfParallelism(2)
            Where Compute(item) > 42
            Select item

Si une requête effectue une quantité importante de travaux non liés au calcul, comme des E/S de fichier, il peut être utile de spécifier un degré de parallélisme supérieur au nombre de cœurs de l’ordinateur.In cases where a query is performing a significant amount of non-compute-bound work such as File I/O, it might be beneficial to specify a degree of parallelism greater than the number of cores on the machine.

Comparatif des requêtes parallèles ordonnées et non ordonnéesOrdered Versus Unordered Parallel Queries

Dans certaines requêtes, un opérateur de requête doit produire des résultats qui conservent l’ordre de la séquence source.In some queries, a query operator must produce results that preserve the ordering of the source sequence. PLINQ fournit l’opérateur AsOrdered à cet effet.PLINQ provides the AsOrdered operator for this purpose. AsOrdered est différent de AsSequential.AsOrdered is distinct from AsSequential. Une séquence AsOrdered est toujours traitée en parallèle, mais ses résultats sont mis en mémoire tampon et triés.An AsOrdered sequence is still processed in parallel, but its results are buffered and sorted. Étant donné que la conservation de l’ordre implique généralement un travail supplémentaire, une séquence AsOrdered peut être traitée plus lentement que la séquence AsUnordered par défaut.Because order preservation typically involves extra work, an AsOrdered sequence might be processed more slowly than the default AsUnordered sequence. Le fait qu’une opération parallèle ordonnée de manière spécifique soit plus rapide qu’une version séquentielle de l’opération dépend de nombreux facteurs.Whether a particular ordered parallel operation is faster than a sequential version of the operation depends on many factors.

L’exemple de code suivant montre comment utiliser la conservation de l’ordre.The following code example shows how to opt in to order preservation.

var evenNums = from num in numbers.AsParallel().AsOrdered()
              where num % 2 == 0
              select num;
Dim evenNums = From num In numbers.AsParallel().AsOrdered()
               Where num Mod 2 = 0
               Select num


Pour plus d’informations, consultez Order Preservation in PLINQ (Conservation de l’ordre dans PLINQ).For more information, see Order Preservation in PLINQ.

Requêtes parallèles et requêtes séquentiellesParallel vs. Sequential Queries

Certaines opérations requièrent que la source de données soit proposée de manière séquentielle.Some operations require that the source data be delivered in a sequential manner. Les opérateurs de requête ParallelEnumerable basculent automatiquement en mode séquentiel lorsque cela est nécessaire.The ParallelEnumerable query operators revert to sequential mode automatically when it is required. Pour les opérateurs de requête et les délégués d’utilisateurs définis par l’utilisateur qui nécessitent une exécution séquentielle, PLINQ fournit la méthode AsSequential.For user-defined query operators and user delegates that require sequential execution, PLINQ provides the AsSequential method. Lorsque vous utilisez AsSequential, tous les opérateurs suivants dans la requête sont exécutés séquentiellement jusqu'à ce que AsParallel soit à nouveau appelé.When you use AsSequential, all subsequent operators in the query are executed sequentially until AsParallel is called again. Pour plus d’informations, voir Comment : combiner des requêtes LINQ parallèles et séquentielles.For more information, see How to: Combine Parallel and Sequential LINQ Queries.

Options de fusion des résultats de requêteOptions for Merging Query Results

Quand une requête PLINQ s’exécute en parallèle, les résultats issus de chaque thread de travail doivent être refusionnés sur le thread principal pour être utilisés par une boucle foreach (For Each en Visual Basic), ou insérés dans une liste ou un tableau.When a PLINQ query executes in parallel, its results from each worker thread must be merged back onto the main thread for consumption by a foreach loop (For Each in Visual Basic), or insertion into a list or array. Dans certains cas, il peut être utile de spécifier un type particulier d’opération de fusion, par exemple, pour commencer à générer des résultats plus rapidement.In some cases, it might be beneficial to specify a particular kind of merge operation, for example, to begin producing results more quickly. Pour cela, PLINQ prend en charge la méthode WithMergeOptions et l’énumération ParallelMergeOptions.For this purpose, PLINQ supports the WithMergeOptions method, and the ParallelMergeOptions enumeration. Pour plus d’informations, consultez l’article Merge Options in PLINQ (Options de fusion de PLINQ).For more information, see Merge Options in PLINQ.

Opérateur ForAllThe ForAll Operator

Dans les requêtes LINQ séquentielles, l’exécution est différée jusqu’à ce que la requête soit énumérée dans une foreach For Each boucle (en Visual Basic) ou en appelant une méthode telle que ToList , ToArray ou ToDictionary .In sequential LINQ queries, execution is deferred until the query is enumerated either in a foreach (For Each in Visual Basic) loop or by invoking a method such as ToList , ToArray , or ToDictionary. Dans PLINQ, vous pouvez également utiliser foreach pour exécuter la requête et itérer dans les résultats.In PLINQ, you can also use foreach to execute the query and iterate through the results. Toutefois, foreach lui-même ne s’exécute pas en parallèle, et par conséquent, requiert que les résultats de toutes les tâches parallèles soient refusionnés dans le thread sur lequel la boucle s’exécute.However, foreach itself does not run in parallel, and therefore, it requires that the output from all parallel tasks be merged back into the thread on which the loop is running. Dans PLINQ, vous pouvez utiliser foreach lorsque vous devez conserver l’ordre final des résultats de requête, et également chaque fois que vous traitez des résultats en série, par exemple, lorsque vous appelez Console.WriteLine pour chaque élément.In PLINQ, you can use foreach when you must preserve the final ordering of the query results, and also whenever you are processing the results in a serial manner, for example when you are calling Console.WriteLine for each element. Pour une exécution plus rapide des requêtes lorsque la conservation de l’ordre n’est pas nécessaire et lorsque le traitement des résultats peut lui-même être parallélisé, utilisez la méthode ForAll pour exécuter une requête PLINQ.For faster query execution when order preservation is not required and when the processing of the results can itself be parallelized, use the ForAll method to execute a PLINQ query. ForAll n’effectue pas cette dernière étape de fusion.ForAll does not perform this final merge step. L'exemple de code suivant montre comment utiliser la méthode ForAll.The following code example shows how to use the ForAll method. System.Collections.Concurrent.ConcurrentBag<T> est utilisée ici, car elle est optimisée pour l’ajout simultané de plusieurs threads sans tentative de suppression d’éléments.System.Collections.Concurrent.ConcurrentBag<T> is used here because it is optimized for multiple threads adding concurrently without attempting to remove any items.

var nums = Enumerable.Range(10, 10000);
var query = from num in nums.AsParallel()
            where num % 10 == 0
            select num;

// Process the results as each thread completes
// and add them to a System.Collections.Concurrent.ConcurrentBag(Of Int)
// which can safely accept concurrent add operations
query.ForAll(e => concurrentBag.Add(Compute(e)));
Dim nums = Enumerable.Range(10, 10000)
Dim query = From num In nums.AsParallel()
            Where num Mod 10 = 0
            Select num

' Process the results as each thread completes
' and add them to a System.Collections.Concurrent.ConcurrentBag(Of Int)
' which can safely accept concurrent add operations
query.ForAll(Sub(e) concurrentBag.Add(Compute(e)))

L’illustration suivante montre la différence entre foreach et ForAll en ce qui concerne l’exécution des requêtes.The following illustration shows the difference between foreach and ForAll with regard to query execution.

ForAll et ForEachForAll vs. ForEach

AnnulationCancellation

PLINQ est intégré aux types d’annulation dans .NET Framework 4.PLINQ is integrated with the cancellation types in .NET Framework 4. (Pour plus d’informations, consultez annulation dans les threads managés.) Par conséquent, contrairement aux requêtes LINQ to Objects séquentielles, les requêtes PLINQ peuvent être annulées.(For more information, see Cancellation in Managed Threads.) Therefore, unlike sequential LINQ to Objects queries, PLINQ queries can be canceled. Pour créer une requête PLINQ annulable, utilisez l’opérateur WithCancellation sur la requête et fournissez une instance CancellationToken comme argument.To create a cancelable PLINQ query, use the WithCancellation operator on the query and provide a CancellationToken instance as the argument. Lorsque la propriété IsCancellationRequested sur le jeton est définie sur true, PLINQ le remarque, arrête le traitement sur tous les threads et lève une OperationCanceledException.When the IsCancellationRequested property on the token is set to true, PLINQ will notice it, stop processing on all threads, and throw an OperationCanceledException.

Il est possible qu’une requête PLINQ continue de traiter certains éléments après la définition du jeton d’annulation.It is possible that a PLINQ query might continue to process some elements after the cancellation token is set.

Pour une plus grande réactivité, vous pouvez également répondre aux demandes d’annulation dans les délégués d’utilisateur de longue durée.For greater responsiveness, you can also respond to cancellation requests in long-running user delegates. Pour plus d’informations, consultez How to: Cancel a PLINQ Query (Guide pratique pour annuler une requête PLINQ).For more information, see How to: Cancel a PLINQ Query.

ExceptionsExceptions

Lorsqu’une requête PLINQ s’exécute, plusieurs exceptions peuvent être générées simultanément à partir de plusieurs threads.When a PLINQ query executes, multiple exceptions might be thrown from different threads simultaneously. En outre, le code destiné à traiter l’exception peut se trouver sur un thread différent de celui du code ayant généré l’exception.Also, the code to handle the exception might be on a different thread than the code that threw the exception. PLINQ utilise le type AggregateException afin d’encapsuler toutes les exceptions levées par une requête et de les marshaler à sur le thread appelant.PLINQ uses the AggregateException type to encapsulate all the exceptions that were thrown by a query, and marshal those exceptions back to the calling thread. Le thread appelant ne requiert qu’un seul bloc try-catch.On the calling thread, only one try-catch block is required. Toutefois, vous pouvez itérer sur toutes les exceptions encapsulées dans AggregateException et intercepter celles à partir desquelles vous pouvez effectuer une récupération en toute sécurité.However, you can iterate through all of the exceptions that are encapsulated in the AggregateException and catch any that you can safely recover from. Dans de rares cas, certaines exceptions qui ne sont pas encapsulées dans AggregateException peuvent être levées, et les exceptions ThreadAbortException ne sont pas non plus incluses dans un wrapper.In rare cases, some exceptions may be thrown that are not wrapped in an AggregateException, and ThreadAbortExceptions are also not wrapped.

Lorsque les exceptions sont autorisées à se propager vers le thread lié, il est possible qu'une requête puisse continuer à traiter des éléments après que l'exception ait été levée.When exceptions are allowed to bubble up back to the joining thread, then it is possible that a query may continue to process some items after the exception is raised.

Pour plus d’informations, consultez How to: Handle Exceptions in a PLINQ Query (Comment : traiter des exceptions dans une requête PLINQ).For more information, see How to: Handle Exceptions in a PLINQ Query.

Partitionneurs personnalisésCustom Partitioners

Dans certains cas, vous pouvez améliorer les performances des requêtes en écrivant un partitionneur personnalisé qui tire parti de certaines caractéristiques de la source de données.In some cases, you can improve query performance by writing a custom partitioner that takes advantage of some characteristic of the source data. Dans la requête, le partitionneur personnalisé lui-même est l’objet énumérable interrogé.In the query, the custom partitioner itself is the enumerable object that is queried.

int[] arr = new int[9999];
Partitioner<int> partitioner = new MyArrayPartitioner<int>(arr);
var query = partitioner.AsParallel().Select(x => SomeFunction(x));
Dim arr(10000) As Integer
Dim partitioner As Partitioner(Of Integer) = New MyArrayPartitioner(Of Integer)(arr)
Dim query = partitioner.AsParallel().Select(Function(x) SomeFunction(x))

PLINQ prend en charge un nombre fixe de partitions (bien que les données puissent être réaffectées de manière dynamique à ces partitions pendant l’exécution pour l’équilibrage de charge.).PLINQ supports a fixed number of partitions (although data may be dynamically reassigned to those partitions during run time for load balancing.). For et ForEach prennent en charge uniquement le partitionnement dynamique, ce qui signifie que le nombre de partitions change en cours d’exécution.For and ForEach support only dynamic partitioning, which means that the number of partitions changes at run time. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et la bibliothèque parallèle de tâches (TPL).For more information, see Custom Partitioners for PLINQ and TPL.

Mesure des performances de PLINQMeasuring PLINQ Performance

Dans de nombreux cas, une requête peut être parallélisée, mais la surcharge liée à la configuration de la requête parallèle annule le gain obtenu en termes de performances.In many cases, a query can be parallelized, but the overhead of setting up the parallel query outweighs the performance benefit gained. Si une requête n’effectue pas beaucoup de calculs ou si la source de données est petite, une requête PLINQ peut être plus lente qu’une requête LINQ to Objects séquentielle.If a query does not perform much computation or if the data source is small, a PLINQ query may be slower than a sequential LINQ to Objects query. Vous pouvez utiliser l’outil d’analyse des performances parallèles de Visual Studio Team Server pour comparer les performances de diverses requêtes, localiser des goulots d’étranglement et déterminer si votre requête s’exécute en parallèle ou de manière séquentielle.You can use the Parallel Performance Analyzer in Visual Studio Team Server to compare the performance of various queries, to locate processing bottlenecks, and to determine whether your query is running in parallel or sequentially. Pour plus d’informations, consultez Visualiseur concurrentiel et How to: Measure PLINQ Query Performance (Comment : mesurer les performances des requêtes PLINQ).For more information, see Concurrency Visualizer and How to: Measure PLINQ Query Performance.

Voir aussiSee also