Parallel.ForEach Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Exécute une opération foreach (For Each dans Visual Basic) dans laquelle les itérations peuvent s’exécuter en parallèle.
Surcharges
| Nom | Description |
|---|---|
| ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>) |
Exécute une opération |
| ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>) |
Exécute une opération |
| ForEach<TSource,TLocal>(Partitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>) |
Exécute une opération |
| ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>) |
Exécute une opération |
| ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>) |
Exécute une opération |
| ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>) |
Exécute une opération |
| ForEach<TSource,TLocal>(Partitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>) |
Exécute une opération |
| ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>) |
Exécute une opération |
| ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource>) |
Exécute une opération |
| ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>) |
Exécute une opération |
| ForEach<TSource>(OrderablePartitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>) |
Exécute une opération |
| ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource>) |
Exécute une opération |
| ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>) |
Exécute une opération |
| ForEach<TSource>(Partitioner<TSource>, Action<TSource,ParallelLoopState>) |
Exécute une opération |
| ForEach<TSource>(Partitioner<TSource>, Action<TSource>) |
Exécute une opération |
| ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState,Int64>) |
Exécute une opération |
| ForEach<TSource>(OrderablePartitioner<TSource>, Action<TSource,ParallelLoopState,Int64>) |
Exécute une opération |
| ForEach<TSource>(IEnumerable<TSource>, Action<TSource>) |
Exécute une opération |
| ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>) |
Exécute une opération |
| ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState>) |
Exécute une opération |
ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) avec des données locales de thread sur un IEnumerable dans lequel les itérations peuvent s’exécuter en parallèle, les options de boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource, typename TLocal>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Generic::IEnumerable<TSource> ^ source, System::Threading::Tasks::ParallelOptions ^ parallelOptions, Func<TLocal> ^ localInit, Func<TSource, System::Threading::Tasks::ParallelLoopState ^, TLocal, TLocal> ^ body, Action<TLocal> ^ localFinally);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource,TLocal>(System.Collections.Generic.IEnumerable<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, Func<TLocal> localInit, Func<TSource,System.Threading.Tasks.ParallelLoopState,TLocal,TLocal> body, Action<TLocal> localFinally);static member ForEach : seq<'Source> * System.Threading.Tasks.ParallelOptions * Func<'Local> * Func<'Source, System.Threading.Tasks.ParallelLoopState, 'Local, 'Local> * Action<'Local> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource, TLocal) (source As IEnumerable(Of TSource), parallelOptions As ParallelOptions, localInit As Func(Of TLocal), body As Func(Of TSource, ParallelLoopState, TLocal, TLocal), localFinally As Action(Of TLocal)) As ParallelLoopResultParamètres de type
- TSource
Type des données dans la source.
- TLocal
Type des données locales de thread.
Paramètres
- source
- IEnumerable<TSource>
Source de données énumérable.
- parallelOptions
- ParallelOptions
Objet qui configure le comportement de cette opération.
- localInit
- Func<TLocal>
Délégué de fonction qui retourne l’état initial des données locales pour chaque tâche.
- body
- Func<TSource,ParallelLoopState,TLocal,TLocal>
Délégué appelé une fois par itération.
- localFinally
- Action<TLocal>
Délégué qui effectue une action finale sur l’état local de chaque tâche.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument source est null.
- ou -
L’argument parallelOptions est null.
- ou -
L’argument body est null.
- ou -
L’argument localInit est null.
- ou -
L’argument localFinally est null.
L’argument CancellationTokenparallelOptions est annulé.
Associé CancellationTokenSource à l’élément CancellationToken dans le fichier parallelOptions a été supprimé.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Remarques
Le body délégué est appelé une fois pour chaque élément dans l’énumérable source . Il est fourni avec les paramètres suivants : l’élément actuel, une ParallelLoopState instance qui peut être utilisée pour décomposer la boucle prématurément, et un état local qui peut être partagé entre les itérations qui s’exécutent sur le même thread.
Le localInit délégué est appelé une fois pour chaque tâche qui participe à l’exécution de la boucle et retourne l’état local initial de chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels sur chaque tâche. Ensuite, chaque appel de corps suivant retourne une valeur d’état éventuellement modifiée qui est passée à l’appel de corps suivant. Enfin, le dernier appel de corps sur chaque tâche retourne une valeur d’état transmise au localFinally délégué. Le localFinally délégué est appelé une fois par thread pour effectuer une action finale sur l’état local de chaque tâche. Ce délégué peut être appelé simultanément sur plusieurs tâches ; par conséquent, vous devez synchroniser l’accès à toutes les variables partagées.
La Parallel.ForEach méthode peut utiliser plus de tâches que de threads pendant la durée de vie de son exécution, car les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela donne à l’objet sous-jacent TaskScheduler la possibilité d’ajouter, de modifier ou de supprimer des threads qui serviceent la boucle.
S’applique à
ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) avec des données locales de thread et des index 64 bits sur un IEnumerable dans lequel les itérations peuvent s’exécuter en parallèle, les options de boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource, typename TLocal>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Generic::IEnumerable<TSource> ^ source, System::Threading::Tasks::ParallelOptions ^ parallelOptions, Func<TLocal> ^ localInit, Func<TSource, System::Threading::Tasks::ParallelLoopState ^, long, TLocal, TLocal> ^ body, Action<TLocal> ^ localFinally);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource,TLocal>(System.Collections.Generic.IEnumerable<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, Func<TLocal> localInit, Func<TSource,System.Threading.Tasks.ParallelLoopState,long,TLocal,TLocal> body, Action<TLocal> localFinally);static member ForEach : seq<'Source> * System.Threading.Tasks.ParallelOptions * Func<'Local> * Func<'Source, System.Threading.Tasks.ParallelLoopState, int64, 'Local, 'Local> * Action<'Local> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource, TLocal) (source As IEnumerable(Of TSource), parallelOptions As ParallelOptions, localInit As Func(Of TLocal), body As Func(Of TSource, ParallelLoopState, Long, TLocal, TLocal), localFinally As Action(Of TLocal)) As ParallelLoopResultParamètres de type
- TSource
Type des données dans la source.
- TLocal
Type des données locales de thread.
Paramètres
- source
- IEnumerable<TSource>
Source de données énumérable.
- parallelOptions
- ParallelOptions
Objet qui configure le comportement de cette opération.
- localInit
- Func<TLocal>
Délégué de fonction qui retourne l’état initial des données locales pour chaque tâche.
- body
- Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>
Délégué appelé une fois par itération.
- localFinally
- Action<TLocal>
Délégué qui effectue une action finale sur l’état local de chaque tâche.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument source est null.
- ou -
L’argument parallelOptions est null.
- ou -
L’argument body est null.
- ou -
L’argument localInit est null.
- ou -
L’argument localFinally est null.
L’argument CancellationTokenparallelOptions est annulé.
Associé CancellationTokenSource à l’élément CancellationToken dans le fichier parallelOptions a été supprimé.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Remarques
Le body délégué est appelé une fois pour chaque élément dans l’énumérable source . Il est fourni avec les paramètres suivants : l’élément actuel, une ParallelLoopState instance qui peut être utilisée pour décomposer la boucle prématurément, l’index de l’élément actuel (Int64) et un état local qui peut être partagé entre les itérations qui s’exécutent sur le même thread.
Le localInit délégué est appelé une fois pour chaque tâche qui participe à l’exécution de la boucle et retourne l’état local initial de chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels sur chaque tâche. Ensuite, chaque appel de corps suivant retourne une valeur d’état éventuellement modifiée qui est passée à l’appel de corps suivant. Enfin, le dernier appel de corps sur chaque tâche retourne une valeur d’état transmise au localFinally délégué. Le localFinally délégué est appelé une fois par thread pour effectuer une action finale sur l’état local de chaque tâche. Ce délégué peut être appelé simultanément sur plusieurs tâches ; par conséquent, vous devez synchroniser l’accès à toutes les variables partagées.
La Parallel.ForEach méthode peut utiliser plus de tâches que de threads pendant la durée de vie de son exécution, car les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela donne à l’objet sous-jacent TaskScheduler la possibilité d’ajouter, de modifier ou de supprimer des threads qui serviceent la boucle.
S’applique à
ForEach<TSource,TLocal>(Partitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) avec des données locales de thread sur une Partitioner dans laquelle les itérations peuvent s’exécuter en parallèle, les options de boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource, typename TLocal>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Concurrent::Partitioner<TSource> ^ source, System::Threading::Tasks::ParallelOptions ^ parallelOptions, Func<TLocal> ^ localInit, Func<TSource, System::Threading::Tasks::ParallelLoopState ^, TLocal, TLocal> ^ body, Action<TLocal> ^ localFinally);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource,TLocal>(System.Collections.Concurrent.Partitioner<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, Func<TLocal> localInit, Func<TSource,System.Threading.Tasks.ParallelLoopState,TLocal,TLocal> body, Action<TLocal> localFinally);static member ForEach : System.Collections.Concurrent.Partitioner<'Source> * System.Threading.Tasks.ParallelOptions * Func<'Local> * Func<'Source, System.Threading.Tasks.ParallelLoopState, 'Local, 'Local> * Action<'Local> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource, TLocal) (source As Partitioner(Of TSource), parallelOptions As ParallelOptions, localInit As Func(Of TLocal), body As Func(Of TSource, ParallelLoopState, TLocal, TLocal), localFinally As Action(Of TLocal)) As ParallelLoopResultParamètres de type
- TSource
Type des éléments dans source.
- TLocal
Type des données locales de thread.
Paramètres
- source
- Partitioner<TSource>
Partitionneur qui contient la source de données d’origine.
- parallelOptions
- ParallelOptions
Objet qui configure le comportement de cette opération.
- localInit
- Func<TLocal>
Délégué de fonction qui retourne l’état initial des données locales pour chaque tâche.
- body
- Func<TSource,ParallelLoopState,TLocal,TLocal>
Délégué appelé une fois par itération.
- localFinally
- Action<TLocal>
Délégué qui effectue une action finale sur l’état local de chaque tâche.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument source est null.
- ou -
L’argument parallelOptions est null.
- ou -
L’argument body est null.
- ou -
L’argument localInit est null.
- ou -
L’argument localFinally est null.
La SupportsDynamicPartitions propriété dans les sourcePartitioner retours false ou le partitionneur retourne null des partitions.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
L’argument CancellationTokenparallelOptions est annulé.
Associé CancellationTokenSource à l’élément CancellationToken dans le fichier parallelOptions a été supprimé.
Remarques
Cette surcharge est fournie pour les scénarios où vous souhaitez remplacer le schéma de partitionnement par défaut. Par exemple, les petits corps de boucle peuvent tirer parti du partitionnement de la plage. La ForEach méthode s’attend à ce que les partitionneurs personnalisés prennent en charge le partitionnement dynamique. Cette surcharge est fournie pour les scénarios avec de petits corps de boucle qui peuvent tirer parti du partitionnement de plage statique. Les partitionneurs doivent prendre en charge les partitions dynamiques. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et TPL etGuide pratique pour implémenter des partitions dynamiques.
Le localInit délégué est appelé une fois pour chaque tâche qui participe à l’exécution de la boucle et retourne l’état local initial de chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels sur chaque tâche. Ensuite, chaque appel de corps suivant retourne une valeur d’état éventuellement modifiée qui est passée à l’appel de corps suivant. Enfin, le dernier appel de corps sur chaque tâche retourne une valeur d’état transmise au localFinally délégué. Le localFinally délégué est appelé une fois par tâche pour effectuer une action finale sur l’état local de chaque tâche. Ce délégué peut être appelé simultanément sur plusieurs tâches ; par conséquent, vous devez synchroniser l’accès à toutes les variables partagées.
La Parallel.ForEach méthode peut utiliser plus de tâches que de threads pendant la durée de vie de son exécution, car les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela donne à l’objet sous-jacent TaskScheduler la possibilité d’ajouter, de modifier ou de supprimer des threads qui serviceent la boucle.
S’applique à
ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) avec des index 64 bits et des données locales de thread sur une OrderablePartitioner<TSource> dans laquelle les itérations peuvent s’exécuter en parallèle, les options de boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource, typename TLocal>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Concurrent::OrderablePartitioner<TSource> ^ source, System::Threading::Tasks::ParallelOptions ^ parallelOptions, Func<TLocal> ^ localInit, Func<TSource, System::Threading::Tasks::ParallelLoopState ^, long, TLocal, TLocal> ^ body, Action<TLocal> ^ localFinally);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource,TLocal>(System.Collections.Concurrent.OrderablePartitioner<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, Func<TLocal> localInit, Func<TSource,System.Threading.Tasks.ParallelLoopState,long,TLocal,TLocal> body, Action<TLocal> localFinally);static member ForEach : System.Collections.Concurrent.OrderablePartitioner<'Source> * System.Threading.Tasks.ParallelOptions * Func<'Local> * Func<'Source, System.Threading.Tasks.ParallelLoopState, int64, 'Local, 'Local> * Action<'Local> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource, TLocal) (source As OrderablePartitioner(Of TSource), parallelOptions As ParallelOptions, localInit As Func(Of TLocal), body As Func(Of TSource, ParallelLoopState, Long, TLocal, TLocal), localFinally As Action(Of TLocal)) As ParallelLoopResultParamètres de type
- TSource
Type des éléments dans source.
- TLocal
Type des données locales de thread.
Paramètres
Partitionneur ordonné qui contient la source de données d’origine.
- parallelOptions
- ParallelOptions
Objet qui configure le comportement de cette opération.
- localInit
- Func<TLocal>
Délégué de fonction qui retourne l’état initial des données locales pour chaque tâche.
- body
- Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>
Délégué appelé une fois par itération.
- localFinally
- Action<TLocal>
Délégué qui effectue une action finale sur l’état local de chaque tâche.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument source est null.
- ou -
L’argument parallelOptions est null.
- ou -
L’argument body est null.
- ou -
L’argument ou localFinally l’argument localInit est null.
La SupportsDynamicPartitions propriété dans les sourcePartitioner retours false ou le partitionneur retourne null des partitions.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
L’argument CancellationTokenparallelOptions est annulé.
Associé CancellationTokenSource à l’élément CancellationToken dans le fichier parallelOptions a été supprimé.
Remarques
Cette surcharge est fournie pour les scénarios où vous souhaitez remplacer le schéma de partitionnement par défaut. Par exemple, les petits corps de boucle peuvent tirer parti du partitionnement de la plage. La ForEach méthode s’attend à ce que les partitionneurs personnalisés prennent en charge le partitionnement dynamique. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et TPL etGuide pratique pour implémenter des partitions dynamiques.
Le localInit délégué est appelé une fois pour chaque tâche qui participe à l’exécution de la boucle et retourne l’état local initial de chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels sur chaque tâche. Ensuite, chaque appel de corps suivant retourne une valeur d’état éventuellement modifiée qui est passée à l’appel de corps suivant. Enfin, le dernier appel de corps sur chaque thread retourne une valeur d’état transmise au localFinally délégué. Le localFinally délégué est appelé une fois par tâche pour effectuer une action finale sur l’état local de chaque tâche. Ce délégué peut être appelé simultanément sur plusieurs tâches ; par conséquent, vous devez synchroniser l’accès à toutes les variables partagées.
La Parallel.ForEach méthode peut utiliser plus de tâches que de threads pendant la durée de vie de son exécution, car les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela donne à l’objet sous-jacent TaskScheduler la possibilité d’ajouter, de modifier ou de supprimer des threads qui serviceent la boucle.
S’applique à
ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) avec des données locales de thread sur un IEnumerable dans lequel les itérations peuvent s’exécuter en parallèle, et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource, typename TLocal>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TLocal> ^ localInit, Func<TSource, System::Threading::Tasks::ParallelLoopState ^, TLocal, TLocal> ^ body, Action<TLocal> ^ localFinally);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource,TLocal>(System.Collections.Generic.IEnumerable<TSource> source, Func<TLocal> localInit, Func<TSource,System.Threading.Tasks.ParallelLoopState,TLocal,TLocal> body, Action<TLocal> localFinally);static member ForEach : seq<'Source> * Func<'Local> * Func<'Source, System.Threading.Tasks.ParallelLoopState, 'Local, 'Local> * Action<'Local> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource, TLocal) (source As IEnumerable(Of TSource), localInit As Func(Of TLocal), body As Func(Of TSource, ParallelLoopState, TLocal, TLocal), localFinally As Action(Of TLocal)) As ParallelLoopResultParamètres de type
- TSource
Type des données dans la source.
- TLocal
Type des données locales de thread.
Paramètres
- source
- IEnumerable<TSource>
Source de données énumérable.
- localInit
- Func<TLocal>
Délégué de fonction qui retourne l’état initial des données locales pour chaque tâche.
- body
- Func<TSource,ParallelLoopState,TLocal,TLocal>
Délégué appelé une fois par itération.
- localFinally
- Action<TLocal>
Délégué qui effectue une action finale sur l’état local de chaque tâche.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument source est null.
- ou -
L’argument body est null.
- ou -
L’argument localInit est null.
- ou -
L’argument localFinally est null.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Exemples
L’exemple suivant montre comment utiliser une méthode avec un ForEach état local :
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
class ForEachWithThreadLocal
{
// Demonstrated features:
// Parallel.ForEach()
// Thread-local state
// Expected results:
// This example sums up the elements of an int[] in parallel.
// Each thread maintains a local sum. When a thread is initialized, that local sum is set to 0.
// On every iteration the current element is added to the local sum.
// When a thread is done, it safely adds its local sum to the global sum.
// After the loop is complete, the global sum is printed out.
// Documentation:
// http://msdn.microsoft.com/library/dd990270(VS.100).aspx
static void Main()
{
// The sum of these elements is 40.
int[] input = { 4, 1, 6, 2, 9, 5, 10, 3 };
int sum = 0;
try
{
Parallel.ForEach(
input, // source collection
() => 0, // thread local initializer
(n, loopState, localSum) => // body
{
localSum += n;
Console.WriteLine("Thread={0}, n={1}, localSum={2}", Thread.CurrentThread.ManagedThreadId, n, localSum);
return localSum;
},
(localSum) => Interlocked.Add(ref sum, localSum) // thread local aggregator
);
Console.WriteLine("\nSum={0}", sum);
}
// No exception is expected in this example, but if one is still thrown from a task,
// it will be wrapped in AggregateException and propagated to the main thread.
catch (AggregateException e)
{
Console.WriteLine("Parallel.ForEach has thrown an exception. THIS WAS NOT EXPECTED.\n{0}", e);
}
}
}
Imports System.Threading
Imports System.Threading.Tasks
Module ForEachDemo
' Demonstrated features:
' Parallel.ForEach()
' Thread-local state
' Expected results:
' This example sums up the elements of an int[] in parallel.
' Each thread maintains a local sum. When a thread is initialized, that local sum is set to 0.
' On every iteration the current element is added to the local sum.
' When a thread is done, it safely adds its local sum to the global sum.
' After the loop is complete, the global sum is printed out.
' Documentation:
' http://msdn.microsoft.com/library/dd990270(VS.100).aspx
Private Sub ForEachDemo()
' The sum of these elements is 40.
Dim input As Integer() = {4, 1, 6, 2, 9, 5, _
10, 3}
Dim sum As Integer = 0
Try
' source collection
Parallel.ForEach(input,
Function()
' thread local initializer
Return 0
End Function,
Function(n, loopState, localSum)
' body
localSum += n
Console.WriteLine("Thread={0}, n={1}, localSum={2}", Thread.CurrentThread.ManagedThreadId, n, localSum)
Return localSum
End Function,
Sub(localSum)
' thread local aggregator
Interlocked.Add(sum, localSum)
End Sub)
Console.WriteLine(vbLf & "Sum={0}", sum)
Catch e As AggregateException
' No exception is expected in this example, but if one is still thrown from a task,
' it will be wrapped in AggregateException and propagated to the main thread.
Console.WriteLine("Parallel.ForEach has thrown an exception. THIS WAS NOT EXPECTED." & vbLf & "{0}", e)
End Try
End Sub
End Module
Remarques
Le body délégué est appelé une fois pour chaque élément dans l’énumérable source . Il est fourni avec les paramètres suivants : l’élément actuel, une ParallelLoopState instance qui peut être utilisée pour décomposer la boucle prématurément, et un état local qui peut être partagé entre les itérations qui s’exécutent sur le même thread.
Le localInit délégué est appelé une fois pour chaque tâche qui participe à l’exécution de la boucle et retourne l’état local initial de chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels sur chaque tâche. Ensuite, chaque appel de corps suivant retourne une valeur d’état éventuellement modifiée qui est passée à l’appel de corps suivant. Enfin, le dernier appel de corps sur chaque tâche retourne une valeur d’état transmise au localFinally délégué. Le localFinally délégué est appelé une fois par thread pour effectuer une action finale sur l’état local de chaque tâche. Ce délégué peut être appelé simultanément sur plusieurs tâches ; par conséquent, vous devez synchroniser l’accès à toutes les variables partagées.
La Parallel.ForEach méthode peut utiliser plus de tâches que de threads pendant la durée de vie de son exécution, car les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela donne à l’objet sous-jacent TaskScheduler la possibilité d’ajouter, de modifier ou de supprimer des threads qui serviceent la boucle.
S’applique à
ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) avec des données locales de thread sur un IEnumerable dans lequel les itérations peuvent s’exécuter en parallèle et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource, typename TLocal>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Generic::IEnumerable<TSource> ^ source, Func<TLocal> ^ localInit, Func<TSource, System::Threading::Tasks::ParallelLoopState ^, long, TLocal, TLocal> ^ body, Action<TLocal> ^ localFinally);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource,TLocal>(System.Collections.Generic.IEnumerable<TSource> source, Func<TLocal> localInit, Func<TSource,System.Threading.Tasks.ParallelLoopState,long,TLocal,TLocal> body, Action<TLocal> localFinally);static member ForEach : seq<'Source> * Func<'Local> * Func<'Source, System.Threading.Tasks.ParallelLoopState, int64, 'Local, 'Local> * Action<'Local> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource, TLocal) (source As IEnumerable(Of TSource), localInit As Func(Of TLocal), body As Func(Of TSource, ParallelLoopState, Long, TLocal, TLocal), localFinally As Action(Of TLocal)) As ParallelLoopResultParamètres de type
- TSource
Type des données dans la source.
- TLocal
Type des données locales de thread.
Paramètres
- source
- IEnumerable<TSource>
Source de données énumérable.
- localInit
- Func<TLocal>
Délégué de fonction qui retourne l’état initial des données locales pour chaque tâche.
- body
- Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>
Délégué appelé une fois par itération.
- localFinally
- Action<TLocal>
Délégué qui effectue une action finale sur l’état local de chaque tâche.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument source est null.
- ou -
L’argument body est null.
- ou -
L’argument localInit est null.
- ou -
L’argument localFinally est null.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Remarques
Le body délégué est appelé une fois pour chaque élément dans l’énumérable source . Il est fourni avec les paramètres suivants : l’élément actuel, une ParallelLoopState instance qui peut être utilisée pour décomposer la boucle prématurément, l’index de l’élément actuel (Int64) et un état local qui peut être partagé entre les itérations qui s’exécutent sur le même thread.
Le localInit délégué est appelé une fois pour chaque tâche qui participe à l’exécution de la boucle et retourne l’état local initial de chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels sur chaque tâche. Ensuite, chaque appel de corps suivant retourne une valeur d’état éventuellement modifiée qui est passée à l’appel de corps suivant. Enfin, le dernier appel de corps sur chaque tâche retourne une valeur d’état transmise au localFinally délégué. Le localFinally délégué est appelé une fois par tâche pour effectuer une action finale sur l’état local de chaque tâche. Ce délégué peut être appelé simultanément sur plusieurs tâches ; par conséquent, vous devez synchroniser l’accès à toutes les variables partagées.
La Parallel.ForEach méthode peut utiliser plus de tâches que de threads pendant la durée de vie de son exécution, car les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela donne à l’objet sous-jacent TaskScheduler la possibilité d’ajouter, de modifier ou de supprimer des threads qui serviceent la boucle.
S’applique à
ForEach<TSource,TLocal>(Partitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) avec des données locales de thread sur une Partitioner dans laquelle les itérations peuvent s’exécuter en parallèle et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource, typename TLocal>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Concurrent::Partitioner<TSource> ^ source, Func<TLocal> ^ localInit, Func<TSource, System::Threading::Tasks::ParallelLoopState ^, TLocal, TLocal> ^ body, Action<TLocal> ^ localFinally);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource,TLocal>(System.Collections.Concurrent.Partitioner<TSource> source, Func<TLocal> localInit, Func<TSource,System.Threading.Tasks.ParallelLoopState,TLocal,TLocal> body, Action<TLocal> localFinally);static member ForEach : System.Collections.Concurrent.Partitioner<'Source> * Func<'Local> * Func<'Source, System.Threading.Tasks.ParallelLoopState, 'Local, 'Local> * Action<'Local> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource, TLocal) (source As Partitioner(Of TSource), localInit As Func(Of TLocal), body As Func(Of TSource, ParallelLoopState, TLocal, TLocal), localFinally As Action(Of TLocal)) As ParallelLoopResultParamètres de type
- TSource
Type des éléments dans source.
- TLocal
Type des données locales de thread.
Paramètres
- source
- Partitioner<TSource>
Partitionneur qui contient la source de données d’origine.
- localInit
- Func<TLocal>
Délégué de fonction qui retourne l’état initial des données locales pour chaque tâche.
- body
- Func<TSource,ParallelLoopState,TLocal,TLocal>
Délégué appelé une fois par itération.
- localFinally
- Action<TLocal>
Délégué qui effectue une action finale sur l’état local de chaque tâche.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument source est null.
- ou -
L’argument body est null.
- ou -
L’argument localInit est null.
- ou -
L’argument localFinally est null.
La SupportsDynamicPartitions propriété dans les sourcePartitioner retours false ou le partitionneur retourne null des partitions.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Remarques
Cette surcharge est fournie pour les scénarios où vous souhaitez remplacer le schéma de partitionnement par défaut. Par exemple, les petits corps de boucle peuvent tirer parti du partitionnement de la plage. La ForEach méthode s’attend à ce que les partitionneurs personnalisés prennent en charge le partitionnement dynamique. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et TPL etGuide pratique pour implémenter des partitions dynamiques.
Le localInit délégué est appelé une fois pour chaque thread qui participe à l’exécution de la boucle et retourne l’état local initial pour chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels sur chaque tâche. Ensuite, chaque appel de corps suivant retourne une valeur d’état éventuellement modifiée qui est passée à l’appel de corps suivant. Enfin, le dernier appel de corps sur chaque tâche retourne une valeur d’état transmise au localFinally délégué. Le localFinally délégué est appelé une fois par tâche pour effectuer une action finale sur l’état local de chaque tâche. Ce délégué peut être appelé simultanément sur plusieurs tâches ; par conséquent, vous devez synchroniser l’accès à toutes les variables partagées.
La Parallel.ForEach méthode peut utiliser plus de tâches que de threads pendant la durée de vie de son exécution, car les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela donne à l’objet sous-jacent TaskScheduler la possibilité d’ajouter, de modifier ou de supprimer des threads qui serviceent la boucle.
S’applique à
ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) avec des données locales de thread sur une OrderablePartitioner<TSource> dans laquelle les itérations peuvent s’exécuter en parallèle, les options de boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource, typename TLocal>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Concurrent::OrderablePartitioner<TSource> ^ source, Func<TLocal> ^ localInit, Func<TSource, System::Threading::Tasks::ParallelLoopState ^, long, TLocal, TLocal> ^ body, Action<TLocal> ^ localFinally);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource,TLocal>(System.Collections.Concurrent.OrderablePartitioner<TSource> source, Func<TLocal> localInit, Func<TSource,System.Threading.Tasks.ParallelLoopState,long,TLocal,TLocal> body, Action<TLocal> localFinally);static member ForEach : System.Collections.Concurrent.OrderablePartitioner<'Source> * Func<'Local> * Func<'Source, System.Threading.Tasks.ParallelLoopState, int64, 'Local, 'Local> * Action<'Local> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource, TLocal) (source As OrderablePartitioner(Of TSource), localInit As Func(Of TLocal), body As Func(Of TSource, ParallelLoopState, Long, TLocal, TLocal), localFinally As Action(Of TLocal)) As ParallelLoopResultParamètres de type
- TSource
Type des éléments dans source.
- TLocal
Type des données locales de thread.
Paramètres
Partitionneur ordonné qui contient la source de données d’origine.
- localInit
- Func<TLocal>
Délégué de fonction qui retourne l’état initial des données locales pour chaque tâche.
- body
- Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>
Délégué appelé une fois par itération.
- localFinally
- Action<TLocal>
Délégué qui effectue une action finale sur l’état local de chaque tâche.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument source est null.
- ou -
L’argument body est null.
- ou -
L’argument localInit est null.
- ou -
L’argument localFinally est null.
La SupportsDynamicPartitions propriété dans les sourcePartitioner retours false ou le partitionneur retourne null des partitions.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Remarques
Cette surcharge est fournie pour les scénarios où vous souhaitez remplacer le schéma de partitionnement par défaut. Par exemple, les petits corps de boucle peuvent tirer parti du partitionnement de la plage. La ForEach méthode s’attend à ce que les partitionneurs personnalisés prennent en charge le partitionnement dynamique. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et TPL etGuide pratique pour implémenter des partitions dynamiques.
Le localInit délégué est appelé une fois pour chaque tâche qui participe à l’exécution de la boucle et retourne l’état local initial de chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels sur chaque tâche. Ensuite, chaque appel de corps suivant retourne une valeur d’état éventuellement modifiée qui est passée à l’appel de corps suivant. Enfin, le dernier appel de corps sur chaque tâche retourne une valeur d’état transmise au localFinally délégué. Le localFinally délégué est appelé une fois par tâche pour effectuer une action finale sur l’état local de chaque tâche. Ce délégué peut être appelé simultanément sur plusieurs tâches ; par conséquent, vous devez synchroniser l’accès à toutes les variables partagées.
La Parallel.ForEach méthode peut utiliser plus de tâches que de threads pendant la durée de vie de son exécution, car les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela donne à l’objet sous-jacent TaskScheduler la possibilité d’ajouter, de modifier ou de supprimer des threads qui serviceent la boucle.
S’applique à
ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) sur un IEnumerable dans lequel les itérations peuvent s’exécuter en parallèle et les options de boucle peuvent être configurées.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Generic::IEnumerable<TSource> ^ source, System::Threading::Tasks::ParallelOptions ^ parallelOptions, Action<TSource> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, Action<TSource> body);static member ForEach : seq<'Source> * System.Threading.Tasks.ParallelOptions * Action<'Source> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource)) As ParallelLoopResultParamètres de type
- TSource
Type des données dans la source.
Paramètres
- source
- IEnumerable<TSource>
Source de données énumérable.
- parallelOptions
- ParallelOptions
Objet qui configure le comportement de cette opération.
- body
- Action<TSource>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument CancellationTokenparallelOptions est annulé
L’argument source est null.
- ou -
L’argument parallelOptions est null.
- ou -
L’argument body est null.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Associé CancellationTokenSource à l’élément CancellationToken dans le fichier parallelOptions a été supprimé.
Remarques
Le body délégué est appelé une fois pour chaque élément dans l’énumérable source . Il est fourni avec l’élément actuel en tant que paramètre.
S’applique à
ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) sur un IEnumerable dans lequel les itérations peuvent s’exécuter en parallèle, les options de boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Generic::IEnumerable<TSource> ^ source, System::Threading::Tasks::ParallelOptions ^ parallelOptions, Action<TSource, System::Threading::Tasks::ParallelLoopState ^> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, Action<TSource,System.Threading.Tasks.ParallelLoopState> body);static member ForEach : seq<'Source> * System.Threading.Tasks.ParallelOptions * Action<'Source, System.Threading.Tasks.ParallelLoopState> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource, ParallelLoopState)) As ParallelLoopResultParamètres de type
- TSource
Type des données dans la source.
Paramètres
- source
- IEnumerable<TSource>
Source de données énumérable.
- parallelOptions
- ParallelOptions
Objet qui configure le comportement de cette opération.
- body
- Action<TSource,ParallelLoopState>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument CancellationTokenparallelOptions est annulé
L’argument source est null.
- ou -
L’argument parallelOptions est null.
- ou -
L’argument body est null.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Associé CancellationTokenSource à l’élément CancellationToken dans le fichier parallelOptions a été supprimé.
Remarques
Le body délégué est appelé une fois pour chaque élément dans l’énumérable source . Il est fourni avec les paramètres suivants : l’élément actuel et une ParallelLoopState instance qui peut être utilisée pour rompre la boucle prématurément.
S’applique à
ForEach<TSource>(OrderablePartitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) sur une opération OrderablePartitioner<TSource> dans laquelle les itérations peuvent s’exécuter en parallèle, les options de boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Concurrent::OrderablePartitioner<TSource> ^ source, System::Threading::Tasks::ParallelOptions ^ parallelOptions, Action<TSource, System::Threading::Tasks::ParallelLoopState ^, long> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.OrderablePartitioner<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, Action<TSource,System.Threading.Tasks.ParallelLoopState,long> body);static member ForEach : System.Collections.Concurrent.OrderablePartitioner<'Source> * System.Threading.Tasks.ParallelOptions * Action<'Source, System.Threading.Tasks.ParallelLoopState, int64> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As OrderablePartitioner(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource, ParallelLoopState, Long)) As ParallelLoopResultParamètres de type
- TSource
Type des éléments dans source.
Paramètres
Partitionneur ordonné qui contient la source de données d’origine.
- parallelOptions
- ParallelOptions
Objet qui configure le comportement de cette opération.
- body
- Action<TSource,ParallelLoopState,Int64>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument CancellationTokenparallelOptions est annulé
L’argument source est null.
- ou -
L’argument parallelOptions est null.
- ou -
L’argument body est null.
Associé CancellationTokenSource à l’élément CancellationToken dans le fichier parallelOptions a été supprimé.
La SupportsDynamicPartitions propriété dans le source partitionneur triable retourne false.
- ou -
La KeysNormalized propriété dans le source partitionneur triable retourne false.
- ou -
Exception levée lorsqu’une méthode dans le source partitionneur ordonné retourne null.
Exception levée pour contenir une exception levée à partir de l’un des délégués spécifiés.
Remarques
Cette surcharge est fournie pour les scénarios où vous souhaitez remplacer le schéma de partitionnement par défaut. Par exemple, les petits corps de boucle peuvent tirer parti du partitionnement de la plage. La Parallel.ForEach méthode s’attend à ce que les partitionneurs personnalisés prennent en charge le partitionnement dynamique. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et TPL etGuide pratique pour implémenter des partitions dynamiques.
S’applique à
ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) sur un Partitioner dans lequel les itérations peuvent s’exécuter en parallèle et les options de boucle peuvent être configurées.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Concurrent::Partitioner<TSource> ^ source, System::Threading::Tasks::ParallelOptions ^ parallelOptions, Action<TSource> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.Partitioner<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, Action<TSource> body);static member ForEach : System.Collections.Concurrent.Partitioner<'Source> * System.Threading.Tasks.ParallelOptions * Action<'Source> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As Partitioner(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource)) As ParallelLoopResultParamètres de type
- TSource
Type des éléments dans source.
Paramètres
- source
- Partitioner<TSource>
Partitionneur qui contient la source de données d’origine.
- parallelOptions
- ParallelOptions
Objet qui configure le comportement de cette opération.
- body
- Action<TSource>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument CancellationTokenparallelOptions est annulé.
Associé CancellationTokenSource à l’élément CancellationToken dans le fichier parallelOptions a été supprimé.
L’argument source est null.
- ou -
L’argument parallelOptions est null.
- ou -
L’argument body est null.
La SupportsDynamicPartitions propriété dans le source partitionneur retourne false.
- ou -
Exception levée lorsqu’une méthode dans le source partitionneur retourne null.
Exception levée pour contenir une exception levée à partir de l’un des délégués spécifiés.
Remarques
Cette surcharge est fournie pour les scénarios où vous souhaitez remplacer le schéma de partitionnement par défaut. Par exemple, les petits corps de boucle peuvent tirer parti du partitionnement de la plage. La Parallel.ForEach méthode s’attend à ce que les partitionneurs personnalisés prennent en charge le partitionnement dynamique. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et TPL etGuide pratique pour implémenter des partitions dynamiques.
S’applique à
ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) avec des index 64 bits sur un IEnumerable dans lequel les itérations peuvent s’exécuter en parallèle, les options de boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Generic::IEnumerable<TSource> ^ source, System::Threading::Tasks::ParallelOptions ^ parallelOptions, Action<TSource, System::Threading::Tasks::ParallelLoopState ^, long> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, Action<TSource,System.Threading.Tasks.ParallelLoopState,long> body);static member ForEach : seq<'Source> * System.Threading.Tasks.ParallelOptions * Action<'Source, System.Threading.Tasks.ParallelLoopState, int64> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource, ParallelLoopState, Long)) As ParallelLoopResultParamètres de type
- TSource
Type des données dans la source.
Paramètres
- source
- IEnumerable<TSource>
Source de données énumérable.
- parallelOptions
- ParallelOptions
Objet qui configure le comportement de cette opération.
- body
- Action<TSource,ParallelLoopState,Int64>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument CancellationTokenparallelOptions est annulé
L’argument source est null.
- ou -
L’argument parallelOptions est null.
- ou -
L’argument body est null.
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Associé CancellationTokenSource à l’élément CancellationToken dans le fichier parallelOptions a été supprimé.
Remarques
Le body délégué est appelé une fois pour chaque élément dans l’énumérable source . Il est fourni avec les paramètres suivants : l’élément actuel, une ParallelLoopState instance qui peut être utilisée pour décomposer la boucle prématurément et l’index de l’élément actuel (Int64).
S’applique à
ForEach<TSource>(Partitioner<TSource>, Action<TSource,ParallelLoopState>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) sur un Partitioner dans lequel les itérations peuvent s’exécuter en parallèle, et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Concurrent::Partitioner<TSource> ^ source, Action<TSource, System::Threading::Tasks::ParallelLoopState ^> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.Partitioner<TSource> source, Action<TSource,System.Threading.Tasks.ParallelLoopState> body);static member ForEach : System.Collections.Concurrent.Partitioner<'Source> * Action<'Source, System.Threading.Tasks.ParallelLoopState> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As Partitioner(Of TSource), body As Action(Of TSource, ParallelLoopState)) As ParallelLoopResultParamètres de type
- TSource
Type des éléments dans source.
Paramètres
- source
- Partitioner<TSource>
Partitionneur qui contient la source de données d’origine.
- body
- Action<TSource,ParallelLoopState>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
La SupportsDynamicPartitions propriété dans le source partitionneur retourne false.
- ou -
Une méthode dans le source partitionneur retourne null.
- ou -
La GetPartitions(Int32) méthode dans le source partitionneur ne retourne pas le nombre correct de partitions.
Exception levée pour contenir une exception levée à partir de l’un des délégués spécifiés.
Remarques
Cette surcharge est fournie pour les scénarios où vous souhaitez remplacer le schéma de partitionnement par défaut. Par exemple, les petits corps de boucle peuvent tirer parti du partitionnement de la plage. La Parallel.ForEach méthode s’attend à ce que les partitionneurs personnalisés prennent en charge le partitionnement dynamique. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et TPL etGuide pratique pour implémenter des partitions dynamiques.
S’applique à
ForEach<TSource>(Partitioner<TSource>, Action<TSource>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) sur une opération Partitioner dans laquelle les itérations peuvent s’exécuter en parallèle.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Concurrent::Partitioner<TSource> ^ source, Action<TSource> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.Partitioner<TSource> source, Action<TSource> body);static member ForEach : System.Collections.Concurrent.Partitioner<'Source> * Action<'Source> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As Partitioner(Of TSource), body As Action(Of TSource)) As ParallelLoopResultParamètres de type
- TSource
Type des éléments dans source.
Paramètres
- source
- Partitioner<TSource>
Partitionneur qui contient la source de données d’origine.
- body
- Action<TSource>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
La SupportsDynamicPartitions propriété dans le source partitionneur retourne false.
- ou -
Exception levée lorsqu’une méthode dans le source partitionneur retourne null.
- ou -
La GetPartitions(Int32) méthode dans le source partitionneur ne retourne pas le nombre correct de partitions.
Exception levée pour contenir une exception levée à partir de l’un des délégués spécifiés.
Exemples
L’exemple suivant montre comment implémenter un partitionneur de plages à utiliser avec Parallel.ForEach:
using System;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
class RangePartitionerDemo
{
static void Main()
{
Stopwatch sw = null;
long sum = 0;
long SUMTOP = 10000000;
// Try sequential for
sw = Stopwatch.StartNew();
for (long i = 0; i < SUMTOP; i++) sum += i;
sw.Stop();
Console.WriteLine("sequential for result = {0}, time = {1} ms", sum, sw.ElapsedMilliseconds);
// Try parallel for -- this is slow!
//sum = 0;
//sw = Stopwatch.StartNew();
//Parallel.For(0L, SUMTOP, (item) => Interlocked.Add(ref sum, item));
//sw.Stop();
//Console.WriteLine("parallel for result = {0}, time = {1} ms", sum, sw.ElapsedMilliseconds);
// Try parallel for with locals
sum = 0;
sw = Stopwatch.StartNew();
Parallel.For(0L, SUMTOP, () => 0L, (item, state, prevLocal) => prevLocal + item, local => Interlocked.Add(ref sum, local));
sw.Stop();
Console.WriteLine("parallel for w/locals result = {0}, time = {1} ms", sum, sw.ElapsedMilliseconds);
// Try range partitioner
sum = 0;
sw = Stopwatch.StartNew();
Parallel.ForEach(Partitioner.Create(0L, SUMTOP), (range) =>
{
long local = 0;
for (long i = range.Item1; i < range.Item2; i++) local += i;
Interlocked.Add(ref sum, local);
});
sw.Stop();
Console.WriteLine("range partitioner result = {0}, time = {1} ms", sum, sw.ElapsedMilliseconds);
}
}
Imports System.Collections.Concurrent
Imports System.Threading
Imports System.Threading.Tasks
Module RangePartitionerDemo
Sub Main()
Dim sw As Stopwatch = Nothing
Dim sum As Long = 0
Dim SUMTOP As Long = 10000000
' Try sequential for
sw = Stopwatch.StartNew()
For i As Long = 0 To SUMTOP - 1
sum += i
Next
sw.Stop()
Console.WriteLine("sequential for result = {0}, time = {1} ms", sum, sw.ElapsedMilliseconds)
' Try parallel for with locals
sum = 0
sw = Stopwatch.StartNew()
Parallel.For(0L, SUMTOP, Function() 0L, Function(item, state, prevLocal) prevLocal + item, Function(local) Interlocked.Add(sum, local))
sw.Stop()
Console.WriteLine("parallel for w/locals result = {0}, time = {1} ms", sum, sw.ElapsedMilliseconds)
' Try range partitioner
sum = 0
sw = Stopwatch.StartNew()
Parallel.ForEach(Partitioner.Create(0L, SUMTOP),
Sub(range)
Dim local As Long = 0
For i As Long = range.Item1 To range.Item2 - 1
local += i
Next
Interlocked.Add(sum, local)
End Sub)
sw.Stop()
Console.WriteLine("range partitioner result = {0}, time = {1} ms", sum, sw.ElapsedMilliseconds)
End Sub
End Module
Remarques
Cette surcharge est fournie pour les scénarios où vous souhaitez remplacer le schéma de partitionnement par défaut. Par exemple, les petits corps de boucle peuvent tirer parti du partitionnement de la plage. La Parallel.ForEach méthode s’attend à ce que les partitionneurs personnalisés prennent en charge le partitionnement dynamique. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et TPL etGuide pratique pour implémenter des partitions dynamiques.
S’applique à
ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState,Int64>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) avec des index 64 bits sur un IEnumerable dans lequel les itérations peuvent s’exécuter en parallèle, et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Generic::IEnumerable<TSource> ^ source, Action<TSource, System::Threading::Tasks::ParallelLoopState ^, long> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, Action<TSource,System.Threading.Tasks.ParallelLoopState,long> body);static member ForEach : seq<'Source> * Action<'Source, System.Threading.Tasks.ParallelLoopState, int64> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), body As Action(Of TSource, ParallelLoopState, Long)) As ParallelLoopResultParamètres de type
- TSource
Type des données dans la source.
Paramètres
- source
- IEnumerable<TSource>
Source de données énumérable.
- body
- Action<TSource,ParallelLoopState,Int64>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Remarques
Le body délégué est appelé une fois pour chaque élément dans l’énumérable source . Il est fourni avec les paramètres suivants : l’élément actuel, une ParallelLoopState instance qui peut être utilisée pour décomposer la boucle prématurément et l’index de l’élément actuel (Int64).
S’applique à
ForEach<TSource>(OrderablePartitioner<TSource>, Action<TSource,ParallelLoopState,Int64>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) sur un OrderablePartitioner<TSource> dans lequel les itérations peuvent s’exécuter en parallèle et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Concurrent::OrderablePartitioner<TSource> ^ source, Action<TSource, System::Threading::Tasks::ParallelLoopState ^, long> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.OrderablePartitioner<TSource> source, Action<TSource,System.Threading.Tasks.ParallelLoopState,long> body);static member ForEach : System.Collections.Concurrent.OrderablePartitioner<'Source> * Action<'Source, System.Threading.Tasks.ParallelLoopState, int64> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As OrderablePartitioner(Of TSource), body As Action(Of TSource, ParallelLoopState, Long)) As ParallelLoopResultParamètres de type
- TSource
Type des éléments dans source.
Paramètres
Partitionneur ordonné qui contient la source de données d’origine.
- body
- Action<TSource,ParallelLoopState,Int64>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
La SupportsDynamicPartitions propriété dans le source partitionneur triable retourne false.
- ou -
La KeysNormalized propriété dans le partitionneur triable source retourne false.
- ou -
Toutes les méthodes du partitionneur triable source retournent null.
Exception levée à partir de l’un des délégués spécifiés.
Remarques
Cette surcharge est fournie pour les scénarios où vous souhaitez remplacer le schéma de partitionnement par défaut. Par exemple, les petits corps de boucle peuvent tirer parti du partitionnement de la plage. La Parallel.ForEach méthode s’attend à ce que les partitionneurs personnalisés prennent en charge le partitionnement dynamique. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et TPL etGuide pratique pour implémenter des partitions dynamiques.
S’applique à
ForEach<TSource>(IEnumerable<TSource>, Action<TSource>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) sur un IEnumerable dans lequel les itérations peuvent s’exécuter en parallèle.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Generic::IEnumerable<TSource> ^ source, Action<TSource> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, Action<TSource> body);static member ForEach : seq<'Source> * Action<'Source> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), body As Action(Of TSource)) As ParallelLoopResultParamètres de type
- TSource
Type des données dans la source.
Paramètres
- source
- IEnumerable<TSource>
Source de données énumérable.
- body
- Action<TSource>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Exemples
L’exemple suivant utilise la ForEach<TSource>(IEnumerable<TSource>, Action<TSource>) méthode pour compter le nombre de voyelles et les caractères non blancs dans un fichier texte. Dans ce cas, la ParallelLoopResult valeur retournée par la méthode est ignorée. Notez que, étant donné que les opérations peuvent s’exécuter en parallèle, vous devez vous assurer que l’incrémentation des variables de compteur est une opération atomique et que plusieurs threads n’essaient pas d’accéder simultanément aux variables de compteur. À cet effet, l’exemple utilise l’instruction lock (en C#) et l’instruction SyncLock (dans Visual Basic).
using System;
using System.IO;
using System.Threading.Tasks;
public class Example
{
public static void Main()
{
Task<String> task = ReadCharacters(@".\CallOfTheWild.txt");
String text = task.Result;
int nVowels = 0;
int nNonWhiteSpace = 0;
Object obj = new Object();
ParallelLoopResult result = Parallel.ForEach(text,
(ch) => {
Char uCh = Char.ToUpper(ch);
if ("AEIOUY".IndexOf(uCh) >= 0) {
lock (obj) {
nVowels++;
}
}
if (!Char.IsWhiteSpace(uCh)) {
lock (obj) {
nNonWhiteSpace++;
}
}
} );
Console.WriteLine("Total characters: {0,10:N0}", text.Length);
Console.WriteLine("Total vowels: {0,10:N0}", nVowels);
Console.WriteLine("Total non-white-space: {0,10:N0}", nNonWhiteSpace);
}
private static async Task<String> ReadCharacters(String fn)
{
String text;
using (StreamReader sr = new StreamReader(fn)) {
text = await sr.ReadToEndAsync();
}
return text;
}
}
// The example displays output like the following:
// Total characters: 198,548
// Total vowels: 58,421
// Total non-white-space: 159,461
Imports System.IO
Imports System.Threading.Tasks
Module Example
Public Sub Main()
Dim task As Task(Of String) = ReadCharacters(".\CallOfTheWild.txt")
Dim text As String = task.Result
Dim nVowels As Integer = 0
Dim nNonWhiteSpace As Integer = 0
Dim obj As New Object()
Dim result As ParallelLoopResult = Parallel.ForEach(text,
Sub(ch)
Dim uCh As Char = Char.ToUpper(ch)
If "AEIOUY".IndexOf(uCh) >= 0 Then
SyncLock obj
nVowels += 1
End SyncLock
End If
If Not Char.IsWhiteSpace(uCh) Then
SyncLock obj
nNonWhiteSpace += 1
End SyncLock
End If
End Sub)
Console.WriteLine("Total characters: {0,10:N0}", text.Length)
Console.WriteLine("Total vowels: {0,10:N0}", nVowels)
Console.WriteLine("Total non-white space: {0,10:N0}", nNonWhiteSpace)
End Sub
Private Async Function ReadCharacters(fn As String) As Task(Of String)
Dim text As String
Using sr As New StreamReader(fn)
text = Await sr.ReadToEndAsync()
End Using
Return text
End Function
End Module
' The output from the example resembles the following:
' Total characters: 198,548
' Total vowels: 58,421
' Total non-white space: 159,461
Remarques
Le body délégué est appelé une fois pour chaque élément dans l’énumérable source . Il est fourni avec l’élément actuel en tant que paramètre.
S’applique à
ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) sur une opération Partitioner dans laquelle les itérations peuvent s’exécuter en parallèle, les options de boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Concurrent::Partitioner<TSource> ^ source, System::Threading::Tasks::ParallelOptions ^ parallelOptions, Action<TSource, System::Threading::Tasks::ParallelLoopState ^> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Concurrent.Partitioner<TSource> source, System.Threading.Tasks.ParallelOptions parallelOptions, Action<TSource,System.Threading.Tasks.ParallelLoopState> body);static member ForEach : System.Collections.Concurrent.Partitioner<'Source> * System.Threading.Tasks.ParallelOptions * Action<'Source, System.Threading.Tasks.ParallelLoopState> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As Partitioner(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource, ParallelLoopState)) As ParallelLoopResultParamètres de type
- TSource
Type des éléments dans source.
Paramètres
- source
- Partitioner<TSource>
Partitionneur qui contient la source de données d’origine.
- parallelOptions
- ParallelOptions
Objet qui configure le comportement de cette opération.
- body
- Action<TSource,ParallelLoopState>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
L’argument CancellationTokenparallelOptions est annulé.
Associé CancellationTokenSource à l’élément CancellationToken dans le fichier parallelOptions a été supprimé.
L’argument source est null.
- ou -
L’argument parallelOptions est null.
- ou -
L’argument body est null.
La SupportsDynamicPartitions propriété dans le source partitionneur retourne false.
- ou -
Exception levée lorsqu’une méthode dans le source partitionneur retourne null.
Exception levée pour contenir une exception levée à partir de l’un des délégués spécifiés.
Remarques
Cette surcharge est fournie pour les scénarios où vous souhaitez remplacer le schéma de partitionnement par défaut. Par exemple, les petits corps de boucle peuvent tirer parti du partitionnement de la plage. La Parallel.ForEach méthode s’attend à ce que les partitionneurs personnalisés prennent en charge le partitionnement dynamique. Pour plus d’informations, consultez Partitionneurs personnalisés pour PLINQ et TPL etGuide pratique pour implémenter des partitions dynamiques.
S’applique à
ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState>)
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
- Source:
- Parallel.cs
Exécute une opération foreach (For Each dans Visual Basic) sur un IEnumerable dans lequel les itérations peuvent s’exécuter en parallèle, et l’état de la boucle peut être surveillé et manipulé.
public:
generic <typename TSource>
static System::Threading::Tasks::ParallelLoopResult ForEach(System::Collections::Generic::IEnumerable<TSource> ^ source, Action<TSource, System::Threading::Tasks::ParallelLoopState ^> ^ body);public static System.Threading.Tasks.ParallelLoopResult ForEach<TSource>(System.Collections.Generic.IEnumerable<TSource> source, Action<TSource,System.Threading.Tasks.ParallelLoopState> body);static member ForEach : seq<'Source> * Action<'Source, System.Threading.Tasks.ParallelLoopState> -> System.Threading.Tasks.ParallelLoopResultPublic Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), body As Action(Of TSource, ParallelLoopState)) As ParallelLoopResultParamètres de type
- TSource
Type des données dans la source.
Paramètres
- source
- IEnumerable<TSource>
Source de données énumérable.
- body
- Action<TSource,ParallelLoopState>
Délégué appelé une fois par itération.
Retours
Structure qui contient des informations sur la partie de la boucle terminée.
Exceptions
Exception qui contient toutes les exceptions individuelles levées sur tous les threads.
Remarques
Le body délégué est appelé une fois pour chaque élément dans l’énumérable source . Il est fourni avec les paramètres suivants : l’élément actuel et une ParallelLoopState instance qui peut être utilisée pour rompre la boucle prématurément.
