Parallel.ForEach Méthode

Définition

Espace de noms:

System.Threading.Tasks

Assembly:

System.Threading.Tasks.Parallel.dll

Exécute une opération foreach (For Each en Visual Basic) dans laquelle les itérations peuvent s'exécuter en parallèle.

Surcharges

ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur IEnumerable dans laquelle les itérations peuvent s’exécuter en parallèle, les options de la boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.
ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread et des index 64 bits sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource,TLocal>(Partitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	Exécute une foreach opération (For Each en Visual Basic) avec des index 64 bits et avec des données locales de thread sur un OrderablePartitioner<TSource> 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é.
ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource,TLocal>(Partitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur OrderablePartitioner<TSource> dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource>)	Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et les options de la boucle peuvent être configurées.
ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)	Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource>(OrderablePartitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)	Exécute une opération foreach (For Each en Visual Basic) sur OrderablePartitioner<TSource> dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource>)	Exécute une opération foreach (For Each en Visual Basic) sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle et les options de la boucle peuvent être configurées.
ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)	Exécute une opération foreach (For Each en Visual Basic) avec des index 64 bits sur IEnumerable 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é.
ForEach<TSource>(Partitioner<TSource>, Action<TSource,ParallelLoopState>)	Exécute une opération foreach (For Each en Visual Basic) sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource>(Partitioner<TSource>, Action<TSource>)	Exécute une opération foreach (For Each en Visual Basic) sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle.
ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState,Int64>)	Exécute une opération foreach (For Each en Visual Basic) avec des index 64 bits sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource>(OrderablePartitioner<TSource>, Action<TSource,ParallelLoopState,Int64>)	Exécute une opération foreach (For Each en Visual Basic) sur OrderablePartitioner<TSource> dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource>(IEnumerable<TSource>, Action<TSource>)	Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle.
ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)	Exécute une opération foreach (For Each en Visual Basic) sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.
ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState>)	Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.

ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur IEnumerable dans laquelle les itérations peuvent s’exécuter en parallèle, les options de la 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.ParallelLoopResult

Public 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 ParallelLoopResult

Paramètres de type

TSource

Type des données contenues 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 exécute une dernière action sur l'état local de chaque tâche.

Retours

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument parallelOptions a la valeur null.

- ou -

L'argument body a la valeur null.

- ou -

L'argument localInit a la valeur null.

- ou -

L'argument localFinally a la valeur null.

OperationCanceledException

CancellationToken dans l'argument parallelOptions est annulé.

ObjectDisposedException

Objet CancellationTokenSource associé à CancellationToken dans l'objet parallelOptions a été supprimé.

AggregateException

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, un ParallelLoopState instance qui peut être utilisé pour sortir prématurément de la boucle, 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 pour chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels de 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 qui est passée 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 toute la durée de son exécution, à mesure que les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela permet à l’objet sous-jacent TaskScheduler d’ajouter, de modifier ou de supprimer des threads qui traitent la boucle.

Voir aussi

• Boucles parallèles

ForEach<TSource,TLocal>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread et des index 64 bits sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la 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.ParallelLoopResult

Public 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 ParallelLoopResult

Paramètres de type

TSource

Type des données contenues 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 exécute une dernière action sur l'état local de chaque tâche.

Retours

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument parallelOptions a la valeur null.

- ou -

L'argument body a la valeur null.

- ou -

L'argument localInit a la valeur null.

- ou -

L'argument localFinally a la valeur null.

OperationCanceledException

CancellationToken dans l'argument parallelOptions est annulé.

ObjectDisposedException

Objet CancellationTokenSource associé à CancellationToken dans l'objet parallelOptions a été supprimé.

AggregateException

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, un ParallelLoopState instance qui peut être utilisé pour sortir prématurément de la boucle, 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 pour chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels de 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 qui est passée au localFinally délégué. Le localFinally délégué est appelé une seule 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 au cours de sa durée d’exécution, à mesure que les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela permet à l’objet sous-jacent TaskScheduler d’ajouter, de modifier ou de supprimer des threads qui service la boucle.

Voir aussi

• Boucles parallèles

ForEach<TSource,TLocal>(Partitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la 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.ParallelLoopResult

Public 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 ParallelLoopResult

Paramè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 exécute une dernière action sur l'état local de chaque tâche.

Retours

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument parallelOptions a la valeur null.

- ou -

L'argument body a la valeur null.

- ou -

L'argument localInit a la valeur null.

- ou -

L'argument localFinally a la valeur null.

InvalidOperationException

La propriété SupportsDynamicPartitions dans sourcePartitioner retourne false ou le partitionneur retourne des partitions null.

AggregateException

Exception qui contient toutes les exceptions individuelles levées sur tous les threads.

OperationCanceledException

CancellationToken dans l'argument parallelOptions est annulé.

ObjectDisposedException

Objet CancellationTokenSource associé à CancellationToken dans l'objet 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 boucles 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 boucles 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 et Guide 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 pour chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels de 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 qui est passée au localFinally délégué. Le localFinally délégué est appelé une seule 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 au cours de sa durée d’exécution, à mesure que les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela permet à l’objet sous-jacent TaskScheduler d’ajouter, de modifier ou de supprimer des threads qui service la boucle.

Voir aussi

• Boucles parallèles

ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)

Source:

Parallel.cs

Exécute une foreach opération (For Each en Visual Basic) avec des index 64 bits et avec des données locales de thread sur un OrderablePartitioner<TSource> 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::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.ParallelLoopResult

Public 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 ParallelLoopResult

Paramètres de type

TSource

Type des éléments dans source.

TLocal

Type des données locales de thread.

Paramètres

source

OrderablePartitioner<TSource>

Partitionneur classable 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 exécute une dernière action sur l'état local de chaque tâche.

Retours

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument parallelOptions a la valeur null.

- ou -

L'argument body a la valeur null.

- ou -

L'argument localInit ou localFinally est null.

InvalidOperationException

La propriété SupportsDynamicPartitions dans sourcePartitioner retourne false ou le partitionneur retourne des partitions null.

AggregateException

Exception qui contient toutes les exceptions individuelles levées sur tous les threads.

OperationCanceledException

CancellationToken dans l'argument parallelOptions est annulé.

ObjectDisposedException

Objet CancellationTokenSource associé à CancellationToken dans l'objet 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 boucles 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 et Guide 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 pour chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels de 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 qui est passée au localFinally délégué. Le localFinally délégué est appelé une seule 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 au cours de sa durée d’exécution, à mesure que les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela permet à l’objet sous-jacent TaskScheduler d’ajouter, de modifier ou de supprimer des threads qui service la boucle.

Voir aussi

• Boucles parallèles

ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur IEnumerable 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::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.ParallelLoopResult

Public 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 ParallelLoopResult

Paramètres de type

TSource

Type des données contenues 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 exécute une dernière action sur l'état local de chaque tâche.

Retours

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument body a la valeur null.

- ou -

L'argument localInit a la valeur null.

- ou -

L'argument localFinally a la valeur null.

AggregateException

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, un ParallelLoopState instance qui peut être utilisé pour sortir prématurément de la boucle, 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 pour chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels de 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 qui est passée au localFinally délégué. Le localFinally délégué est appelé une seule 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 au cours de sa durée d’exécution, à mesure que les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela permet à l’objet sous-jacent TaskScheduler d’ajouter, de modifier ou de supprimer des threads qui service la boucle.

Voir aussi

• Boucles parallèles

ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur IEnumerable 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::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.ParallelLoopResult

Public 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 ParallelLoopResult

Paramètres de type

TSource

Type des données contenues 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 exécute une dernière action sur l'état local de chaque tâche.

Retours

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument body a la valeur null.

- ou -

L'argument localInit a la valeur null.

- ou -

L'argument localFinally a la valeur null.

AggregateException

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, un ParallelLoopState instance qui peut être utilisé pour sortir prématurément de la boucle, 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 pour chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels de 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 qui est passée au localFinally délégué. Le localFinally délégué est appelé une seule 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 au cours de sa durée d’exécution, à mesure que les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela permet à l’objet sous-jacent TaskScheduler d’ajouter, de modifier ou de supprimer des threads qui service la boucle.

Voir aussi

• Boucles parallèles

ForEach<TSource,TLocal>(Partitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur 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.ParallelLoopResult

Public 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 ParallelLoopResult

Paramè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 exécute une dernière action sur l'état local de chaque tâche.

Retours

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument body a la valeur null.

- ou -

L'argument localInit a la valeur null.

- ou -

L'argument localFinally a la valeur null.

InvalidOperationException

La propriété SupportsDynamicPartitions dans sourcePartitioner retourne false ou le partitionneur retourne des partitions null.

AggregateException

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 boucles 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 et Guide 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 de 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 qui est passée au localFinally délégué. Le localFinally délégué est appelé une seule 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 au cours de sa durée d’exécution, à mesure que les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela permet à l’objet sous-jacent TaskScheduler d’ajouter, de modifier ou de supprimer des threads qui service la boucle.

Voir aussi

• Boucles parallèles

ForEach<TSource,TLocal>(OrderablePartitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur OrderablePartitioner<TSource> dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la 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.ParallelLoopResult

Public 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 ParallelLoopResult

Paramètres de type

TSource

Type des éléments dans source.

TLocal

Type des données locales de thread.

Paramètres

source

OrderablePartitioner<TSource>

Partitionneur classable 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 exécute une dernière action sur l'état local de chaque tâche.

Retours

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument body a la valeur null.

- ou -

L'argument localInit a la valeur null.

- ou -

L'argument localFinally a la valeur null.

InvalidOperationException

La propriété SupportsDynamicPartitions dans sourcePartitioner retourne false ou le partitionneur retourne des partitions null.

AggregateException

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 boucles 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 et Guide 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 pour chacune de ces tâches. Ces états initiaux sont passés aux premiers body appels de 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 qui est passée au localFinally délégué. Le localFinally délégué est appelé une seule 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 au cours de sa durée d’exécution, à mesure que les tâches existantes se terminent et sont remplacées par de nouvelles tâches. Cela permet à l’objet sous-jacent TaskScheduler d’ajouter, de modifier ou de supprimer des threads qui service la boucle.

Voir aussi

• Boucles parallèles

ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et les options de la 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource)) As ParallelLoopResult

Paramètres de type

TSource

Type des données contenues 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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

OperationCanceledException

CancellationToken dans l'argument parallelOptions est annulé

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument parallelOptions a la valeur null.

- ou -

L'argument body a la valeur null.

AggregateException

Exception qui contient toutes les exceptions individuelles levées sur tous les threads.

ObjectDisposedException

Objet CancellationTokenSource associé à CancellationToken dans l'objet 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.

Voir aussi

• Boucles parallèles

ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource, ParallelLoopState)) As ParallelLoopResult

Paramètres de type

TSource

Type des données contenues 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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

OperationCanceledException

CancellationToken dans l'argument parallelOptions est annulé

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument parallelOptions a la valeur null.

- ou -

L'argument body a la valeur null.

AggregateException

Exception qui contient toutes les exceptions individuelles levées sur tous les threads.

ObjectDisposedException

Objet CancellationTokenSource associé à CancellationToken dans l'objet 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 un ParallelLoopState instance qui peut être utilisé pour sortir prématurément de la boucle.

Voir aussi

• Boucles parallèles

ForEach<TSource>(OrderablePartitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) sur OrderablePartitioner<TSource> dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As OrderablePartitioner(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource, ParallelLoopState, Long)) As ParallelLoopResult

Paramètres de type

TSource

Type des éléments dans source.

Paramètres

source

OrderablePartitioner<TSource>

Partitionneur classable 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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

OperationCanceledException

CancellationToken dans l'argument parallelOptions est annulé

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument parallelOptions a la valeur null.

- ou -

L'argument body a la valeur null.

ObjectDisposedException

Objet CancellationTokenSource associé à CancellationToken dans l'objet parallelOptions a été supprimé.

InvalidOperationException

La propriété SupportsDynamicPartitions dans le partitionneur classable source retourne la valeur false.

- ou -

La propriété KeysNormalized dans le partitionneur classable source retourne la valeur false.

- ou -

L'exception levée lorsque toute méthode dans l'OrderablePartitioner source retourne une valeur null.

AggregateException

Exception envoyée pour contenir une exception envoyée à partir 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 boucles 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 et Guide pratique pour implémenter des partitions dynamiques.

Voir aussi

• Boucles parallèles

ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle et les options de la 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As Partitioner(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource)) As ParallelLoopResult

Paramè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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

OperationCanceledException

CancellationToken dans l'argument parallelOptions est annulé.

ObjectDisposedException

Objet CancellationTokenSource associé à CancellationToken dans l'objet parallelOptions a été supprimé.

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument parallelOptions a la valeur null.

- ou -

L'argument body a la valeur null.

InvalidOperationException

La propriété SupportsDynamicPartitions du partitionneur source retourne false.

- ou -

Exception levée lorsque toutes les méthodes dans le partitionneur source retournent la valeur null.

AggregateException

Exception envoyée pour contenir une exception envoyée à partir 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 boucles 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 et Guide pratique pour implémenter des partitions dynamiques.

Voir aussi

• Boucles parallèles

ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) avec des index 64 bits sur IEnumerable 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::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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource, ParallelLoopState, Long)) As ParallelLoopResult

Paramètres de type

TSource

Type des données contenues 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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

OperationCanceledException

CancellationToken dans l'argument parallelOptions est annulé

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument parallelOptions a la valeur null.

- ou -

L'argument body a la valeur null.

AggregateException

Exception qui contient toutes les exceptions individuelles levées sur tous les threads.

ObjectDisposedException

Objet CancellationTokenSource associé à CancellationToken dans l'objet 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, un ParallelLoopState instance qui peut être utilisé pour sortir prématurément de la boucle et l’index de l’élément actuel (Int64).

Voir aussi

• Boucles parallèles

ForEach<TSource>(Partitioner<TSource>, Action<TSource,ParallelLoopState>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) sur 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>
 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As Partitioner(Of TSource), body As Action(Of TSource, ParallelLoopState)) As ParallelLoopResult

Paramè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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument body a la valeur null.

InvalidOperationException

La propriété SupportsDynamicPartitions du partitionneur source retourne false.

- ou -

Une méthode du partitioneur source retourne null.

- ou -

La méthode GetPartitions(Int32) dans le source ne retourne pas le nombre correct de partitions.

AggregateException

Exception envoyée pour contenir une exception envoyée à partir 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 boucles 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 et Guide pratique pour implémenter des partitions dynamiques.

Voir aussi

• Boucles parallèles

ForEach<TSource>(Partitioner<TSource>, Action<TSource>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) sur 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As Partitioner(Of TSource), body As Action(Of TSource)) As ParallelLoopResult

Paramè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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument body a la valeur null.

InvalidOperationException

La propriété SupportsDynamicPartitions du partitionneur source retourne false.

- ou -

Exception levée lorsque toutes les méthodes dans le partitionneur source retournent la valeur null.

- ou -

La méthode GetPartitions(Int32) dans le source ne retourne pas le nombre correct de partitions.

AggregateException

Exception envoyée pour contenir une exception envoyée à partir des délégués spécifiés.

Exemples

L’exemple suivant montre comment implémenter un partitionneur de plage à 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 boucles 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 et Guide pratique pour implémenter des partitions dynamiques.

Voir aussi

• Boucles parallèles

ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState,Int64>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) avec des index 64 bits sur IEnumerable 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>
 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), body As Action(Of TSource, ParallelLoopState, Long)) As ParallelLoopResult

Paramètres de type

TSource

Type des données contenues 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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument body a la valeur null.

AggregateException

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, un ParallelLoopState instance qui peut être utilisé pour sortir prématurément de la boucle et l’index de l’élément actuel (Int64).

Voir aussi

• Boucles parallèles

ForEach<TSource>(OrderablePartitioner<TSource>, Action<TSource,ParallelLoopState,Int64>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) sur OrderablePartitioner<TSource> 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>
 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As OrderablePartitioner(Of TSource), body As Action(Of TSource, ParallelLoopState, Long)) As ParallelLoopResult

Paramètres de type

TSource

Type des éléments dans source.

Paramètres

source

OrderablePartitioner<TSource>

Partitionneur classable qui contient la source de données d'origine.

body

Action<TSource,ParallelLoopState,Int64>

Délégué appelé une fois par itération.

Retours

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument body a la valeur null.

InvalidOperationException

La propriété SupportsDynamicPartitions dans le partitionneur classable source retourne la valeur false.

- ou -

La propriété KeysNormalized dans le partitionneur classable de source retourne false.

- ou -

Toutes les méthodes dans le partitionneur classable source retournent null.

AggregateException

Exception levée depuis 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 boucles 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 et Guide pratique pour implémenter des partitions dynamiques.

Voir aussi

• Boucles parallèles

ForEach<TSource>(IEnumerable<TSource>, Action<TSource>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable dans laquelle 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), body As Action(Of TSource)) As ParallelLoopResult

Paramètres de type

TSource

Type des données contenues 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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument body a la valeur null.

AggregateException

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 de caractères autres que les espaces 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 ne tentent pas d’accéder aux variables de compteur simultanément. À cet effet, l’exemple utilise l’instruction lock (en C#) et l’instruction SyncLock (en 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.

Voir aussi

• Boucles parallèles

ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As Partitioner(Of TSource), parallelOptions As ParallelOptions, body As Action(Of TSource, ParallelLoopState)) As ParallelLoopResult

Paramè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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

OperationCanceledException

CancellationToken dans l'argument parallelOptions est annulé.

ObjectDisposedException

Objet CancellationTokenSource associé à CancellationToken dans l'objet parallelOptions a été supprimé.

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument parallelOptions a la valeur null.

- ou -

L'argument body a la valeur null.

InvalidOperationException

La propriété SupportsDynamicPartitions du partitionneur source retourne false.

- ou -

Exception levée lorsque toutes les méthodes dans le partitionneur source retournent la valeur null.

AggregateException

Exception envoyée pour contenir une exception envoyée à partir 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 boucles 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 et Guide pratique pour implémenter des partitions dynamiques.

Voir aussi

• Boucles parallèles

ForEach<TSource>(IEnumerable<TSource>, Action<TSource,ParallelLoopState>)

Source:

Parallel.cs

Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable 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>
 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.ParallelLoopResult

Public Shared Function ForEach(Of TSource) (source As IEnumerable(Of TSource), body As Action(Of TSource, ParallelLoopState)) As ParallelLoopResult

Paramètres de type

TSource

Type des données contenues 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

ParallelLoopResult

Structure qui contient des informations sur la partie de la boucle terminée.

Exceptions

ArgumentNullException

L'argument source a la valeur null.

- ou -

L'argument body a la valeur null.

AggregateException

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 un ParallelLoopState instance qui peut être utilisé pour sortir prématurément de la boucle.

Voir aussi

• Boucles parallèles