Parallel.ForEach Método

Definición

Ejecuta una operación foreach (For Each en Visual Basic) en la que es posible ejecutar iteraciones en paralelo.Executes a foreach (For Each in Visual Basic) operation in which iterations may run in parallel.

Sobrecargas

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en IEnumerable donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) con índices de 64 bits y datos locales del subproceso en IEnumerable donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data and 64-bit indexes on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en Partitioner donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on a Partitioner in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) con índices de 64 bits y datos locales del subproceso en OrderablePartitioner<TSource> donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes and with thread-local data on a OrderablePartitioner<TSource> in which iterations may run in parallel , loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en IEnumerable donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on an IEnumerable in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en IEnumerable donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on an IEnumerable in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en Partitioner donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on a Partitioner in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en OrderablePartitioner<TSource> donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on a OrderablePartitioner<TSource> in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) en IEnumerable donde se pueden ejecutar iteraciones en paralelo y configurar las opciones de bucle.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel and loop options can be configured.

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

Ejecuta una operación foreach (For Each en Visual Basic) en IEnumerable donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) en IEnumerable donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) en Partitioner donde se pueden ejecutar iteraciones en paralelo y configurar las opciones de bucle.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel and loop options can be configured.

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

Ejecuta una operación foreach (For Each en Visual Basic) en Partitioner donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) en OrderablePartitioner<TSource> donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on a OrderablePartitioner<TSource> in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) en IEnumerable, en la que es posible ejecutar iteraciones en paralelo.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel.

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

Ejecuta una operación foreach (For Each en Visual Basic) con índices de 64 bits en IEnumerable donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes on an IEnumerable in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) en Partitioner, en la que es posible ejecutar iteraciones en paralelo.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel.

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

Ejecuta una operación foreach (For Each en Visual Basic) en Partitioner donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) en OrderablePartitioner<TSource> donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on a OrderablePartitioner<TSource> in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each in Visual Basic) con índices de 64 bits en IEnumerable donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en IEnumerable donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los datos del origen.The type of the data in the source.

TLocal

Tipo de los datos locales de subprocesos.The type of the thread-local data.

Parámetros

source
IEnumerable<TSource>

Origen de datos enumerable.An enumerable data source.

parallelOptions
ParallelOptions

Objeto que configura el comportamiento de esta operación.An object that configures the behavior of this operation.

localInit
Func<TLocal>

Delegado de función que devuelve el estado inicial de los datos locales de cada tarea.The function delegate that returns the initial state of the local data for each task.

body
Func<TSource,ParallelLoopState,TLocal,TLocal>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

localFinally
Action<TLocal>

Delegado que realiza una acción final en el estado local de cada tarea.The delegate that performs a final action on the local state of each task.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento parallelOptions es null.The parallelOptions argument is null.

o bien-or- El argumento body es null.The body argument is null.

o bien-or- El argumento localInit es null.The localInit argument is null.

o bien-or- El argumento localFinally es null.The localFinally argument is null.

CancellationToken en el argumento parallelOptions se cancela.The CancellationToken in the parallelOptions argument is canceled.

El objeto CancellationTokenSource asociado a CancellationToken en el parallelOptions se ha desechado.The CancellationTokenSource associated with the CancellationToken in the parallelOptions has been disposed.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

Comentarios

El delegado de body se invoca una vez para cada elemento del source Enumerable.The body delegate is invoked once for each element in the source enumerable. Se proporciona con los parámetros siguientes: el elemento actual, una instancia de ParallelLoopState que se puede usar para salir del bucle prematuramente, y algún estado local que se puede compartir entre las iteraciones que se ejecutan en el mismo subproceso.It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, and some local state that may be shared amongst iterations that execute on the same thread.

El delegado de localInit se invoca una vez para cada tarea que participa en la ejecución del bucle y devuelve el estado local inicial de cada una de esas tareas.The localInit delegate is invoked once for each task that participates in the loop's execution and returns the initial local state for each of those tasks. Estos estados iniciales se pasan al primer body invocaciones en cada tarea.These initial states are passed to the first body invocations on each task. Después, cada invocación del cuerpo subsiguiente devuelve un valor de estado posiblemente modificado que se pasa a la invocación del cuerpo siguiente.Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Por último, la última invocación del cuerpo en cada tarea devuelve un valor de estado que se pasa al delegado localFinally.Finally, the last body invocation on each task returns a state value that is passed to the localFinally delegate. El delegado de localFinally se invoca una vez por subproceso para realizar una acción final en el estado local de cada tarea.The localFinally delegate is invoked once per thread to perform a final action on each task's local state. Este delegado se puede invocar simultáneamente en varias tareas; por lo tanto, debe sincronizar el acceso a las variables compartidas.This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

El método Parallel.ForEach puede usar más tareas que los subprocesos durante su ejecución, ya que las tareas existentes se completan y se reemplazan por nuevas tareas.The Parallel.ForEach method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. Esto proporciona al objeto de TaskScheduler subyacente la oportunidad de agregar, cambiar o quitar los subprocesos que dan servicio al bucle.This gives the underlying TaskScheduler object the chance to add, change, or remove threads that service the loop.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) con índices de 64 bits y datos locales del subproceso en IEnumerable donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data and 64-bit indexes on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los datos del origen.The type of the data in the source.

TLocal

Tipo de los datos locales de subprocesos.The type of the thread-local data.

Parámetros

source
IEnumerable<TSource>

Origen de datos enumerable.An enumerable data source.

parallelOptions
ParallelOptions

Objeto que configura el comportamiento de esta operación.An object that configures the behavior of this operation.

localInit
Func<TLocal>

Delegado de función que devuelve el estado inicial de los datos locales de cada tarea.The function delegate that returns the initial state of the local data for each task.

body
Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

localFinally
Action<TLocal>

Delegado que realiza una acción final en el estado local de cada tarea.The delegate that performs a final action on the local state of each task.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento parallelOptions es null.The parallelOptions argument is null.

o bien-or- El argumento body es null.The body argument is null.

o bien-or- El argumento localInit es null.The localInit argument is null.

o bien-or- El argumento localFinally es null.The localFinally argument is null.

CancellationToken en el argumento parallelOptions se cancela.The CancellationToken in the parallelOptions argument is canceled.

El objeto CancellationTokenSource asociado a CancellationToken en el parallelOptions se ha desechado.The CancellationTokenSource associated with the CancellationToken in the parallelOptions has been disposed.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

Comentarios

El delegado de body se invoca una vez para cada elemento del source Enumerable.The body delegate is invoked once for each element in the source enumerable. Se proporciona con los parámetros siguientes: el elemento actual, una instancia de ParallelLoopState que se puede usar para salir del bucle prematuramente, el índice del elemento actual (Int64) y algún estado local que se puede compartir entre las iteraciones que se ejecutan en el mismo subproceso.It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, the current element's index (Int64), and some local state that may be shared amongst iterations that execute on the same thread.

El delegado de localInit se invoca una vez para cada tarea que participa en la ejecución del bucle y devuelve el estado local inicial de cada una de esas tareas.The localInit delegate is invoked once for each task that participates in the loop's execution and returns the initial local state for each of those tasks. Estos estados iniciales se pasan al primer body invocaciones en cada tarea.These initial states are passed to the first body invocations on each task. Después, cada invocación del cuerpo subsiguiente devuelve un valor de estado posiblemente modificado que se pasa a la invocación del cuerpo siguiente.Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Por último, la última invocación del cuerpo en cada tarea devuelve un valor de estado que se pasa al delegado localFinally.Finally, the last body invocation on each task returns a state value that is passed to the localFinally delegate. El delegado de localFinally se invoca una vez por subproceso para realizar una acción final en el estado local de cada tarea.The localFinally delegate is invoked once per thread to perform a final action on each task's local state. Este delegado se puede invocar simultáneamente en varias tareas; por lo tanto, debe sincronizar el acceso a las variables compartidas.This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

El método Parallel.ForEach puede usar más tareas que los subprocesos durante su ejecución, ya que las tareas existentes se completan y se reemplazan por nuevas tareas.The Parallel.ForEach method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. Esto proporciona al objeto de TaskScheduler subyacente la oportunidad de agregar, cambiar o quitar los subprocesos que dan servicio al bucle.This gives the underlying TaskScheduler object the chance to add, change, or remove threads that service the loop.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en Partitioner donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on a Partitioner in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los elementos de source.The type of the elements in source.

TLocal

Tipo de los datos locales de subprocesos.The type of the thread-local data.

Parámetros

source
Partitioner<TSource>

Particionador que contiene el origen de datos original.The partitioner that contains the original data source.

parallelOptions
ParallelOptions

Objeto que configura el comportamiento de esta operación.An object that configures the behavior of this operation.

localInit
Func<TLocal>

Delegado de función que devuelve el estado inicial de los datos locales de cada tarea.The function delegate that returns the initial state of the local data for each task.

body
Func<TSource,ParallelLoopState,TLocal,TLocal>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

localFinally
Action<TLocal>

Delegado que realiza una acción final en el estado local de cada tarea.The delegate that performs a final action on the local state of each task.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento parallelOptions es null.The parallelOptions argument is null.

o bien-or- El argumento body es null.The body argument is null.

o bien-or- El argumento localInit es null.The localInit argument is null.

o bien-or- El argumento localFinally es null.The localFinally argument is null.

La propiedad SupportsDynamicPartitions de sourcePartitioner devuelve false o el particionador devuelve particiones null.The SupportsDynamicPartitions property in the sourcePartitioner returns false or the partitioner returns null partitions.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

CancellationToken en el argumento parallelOptions se cancela.The CancellationToken in the parallelOptions argument is canceled.

El objeto CancellationTokenSource asociado a CancellationToken en el parallelOptions se ha desechado.The CancellationTokenSource associated with the CancellationToken in the parallelOptions has been disposed.

Comentarios

Esta sobrecarga se proporciona para los escenarios en los que desea invalidar el esquema de partición predeterminado.This overload is provided for scenarios where you want to override the default partitioning scheme. Por ejemplo, los cuerpos de bucle pequeños podrían beneficiarse de la creación de particiones del intervalo.For example, small loop bodies might benefit from partitioning the range. El método ForEach espera que los particionadores personalizados admitan la creación de particiones dinámicas.The ForEach method expects custom partitioners to support dynamic partitioning. Esta sobrecarga se proporciona para escenarios con cuerpos de bucle pequeños que podrían beneficiarse de la creación de particiones por rangos estáticos.This overload is provided for scenarios with small loop bodies that might benefit from static range partitioning. Los particionadores deben admitir las particiones dinámicas.Partitioners must support dynamic partitions. Para obtener más información, consulte particionadores personalizados para PLINQ y TPL y Cómo: implementar particiones dinámicas.For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

El delegado de localInit se invoca una vez para cada tarea que participa en la ejecución del bucle y devuelve el estado local inicial de cada una de esas tareas.The localInit delegate is invoked once for each task that participates in the loop's execution and returns the initial local state for each of those tasks. Estos estados iniciales se pasan al primer body invocaciones en cada tarea.These initial states are passed to the first body invocations on each task. Después, cada invocación del cuerpo subsiguiente devuelve un valor de estado posiblemente modificado que se pasa a la invocación del cuerpo siguiente.Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Por último, la última invocación del cuerpo en cada tarea devuelve un valor de estado que se pasa al delegado localFinally.Finally, the last body invocation on each task returns a state value that is passed to the localFinally delegate. El delegado de localFinally se invoca una vez por tarea para realizar una acción final en el estado local de cada tarea.The localFinally delegate is invoked once per task to perform a final action on each task's local state. Este delegado se puede invocar simultáneamente en varias tareas; por lo tanto, debe sincronizar el acceso a las variables compartidas.This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

El método Parallel.ForEach puede usar más tareas que los subprocesos durante su ejecución, ya que las tareas existentes se completan y se reemplazan por nuevas tareas.The Parallel.ForEach method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. Esto proporciona al objeto de TaskScheduler subyacente la oportunidad de agregar, cambiar o quitar los subprocesos que dan servicio al bucle.This gives the underlying TaskScheduler object the chance to add, change, or remove threads that service the loop.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) con índices de 64 bits y datos locales del subproceso en OrderablePartitioner<TSource> donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes and with thread-local data on a OrderablePartitioner<TSource> in which iterations may run in parallel , loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los elementos de source.The type of the elements in source.

TLocal

Tipo de los datos locales de subprocesos.The type of the thread-local data.

Parámetros

source
OrderablePartitioner<TSource>

Particionador ordenable que contiene el origen de datos original.The orderable partitioner that contains the original data source.

parallelOptions
ParallelOptions

Objeto que configura el comportamiento de esta operación.An object that configures the behavior of this operation.

localInit
Func<TLocal>

Delegado de función que devuelve el estado inicial de los datos locales de cada tarea.The function delegate that returns the initial state of the local data for each task.

body
Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

localFinally
Action<TLocal>

Delegado que realiza una acción final en el estado local de cada tarea.The delegate that performs a final action on the local state of each task.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento parallelOptions es null.The parallelOptions argument is null.

o bien-or- El argumento body es null.The body argument is null.

o bien-or- El argumento localInit o localFinally es null.The localInit or localFinally argument is null.

La propiedad SupportsDynamicPartitions de sourcePartitioner devuelve false o el particionador devuelve particiones null.The SupportsDynamicPartitions property in the sourcePartitioner returns false or the partitioner returns null partitions.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

CancellationToken en el argumento parallelOptions se cancela.The CancellationToken in the parallelOptions argument is canceled.

El objeto CancellationTokenSource asociado a CancellationToken en el parallelOptions se ha desechado.The CancellationTokenSource associated with the CancellationToken in the parallelOptions has been disposed.

Comentarios

Esta sobrecarga se proporciona para los escenarios en los que desea invalidar el esquema de partición predeterminado.This overload is provided for scenarios where you want to override the default partitioning scheme. Por ejemplo, los cuerpos de bucle pequeños podrían beneficiarse de la creación de particiones del intervalo.For example, small loop bodies might benefit from partitioning the range. El método ForEach espera que los particionadores personalizados admitan la creación de particiones dinámicas.The ForEach method expects custom partitioners to support dynamic partitioning. Para obtener más información, consulte particionadores personalizados para PLINQ y TPL y Cómo: implementar particiones dinámicas.For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

El delegado de localInit se invoca una vez para cada tarea que participa en la ejecución del bucle y devuelve el estado local inicial de cada una de esas tareas.The localInit delegate is invoked once for each task that participates in the loop's execution and returns the initial local state for each of those tasks. Estos estados iniciales se pasan al primer body invocaciones en cada tarea.These initial states are passed to the first body invocations on each task. Después, cada invocación del cuerpo subsiguiente devuelve un valor de estado posiblemente modificado que se pasa a la invocación del cuerpo siguiente.Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Por último, la última invocación del cuerpo en cada subproceso devuelve un valor de estado que se pasa al delegado de localFinally.Finally, the last body invocation on each thread returns a state value that is passed to the localFinally delegate. El delegado de localFinally se invoca una vez por tarea para realizar una acción final en el estado local de cada tarea.The localFinally delegate is invoked once per task to perform a final action on each task's local state. Este delegado se puede invocar simultáneamente en varias tareas; por lo tanto, debe sincronizar el acceso a las variables compartidas.This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

El método Parallel.ForEach puede usar más tareas que los subprocesos durante su ejecución, ya que las tareas existentes se completan y se reemplazan por nuevas tareas.The Parallel.ForEach method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. Esto proporciona al objeto de TaskScheduler subyacente la oportunidad de agregar, cambiar o quitar los subprocesos que dan servicio al bucle.This gives the underlying TaskScheduler object the chance to add, change, or remove threads that service the loop.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en IEnumerable donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on an IEnumerable in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los datos del origen.The type of the data in the source.

TLocal

Tipo de los datos locales de subprocesos.The type of the thread-local data.

Parámetros

source
IEnumerable<TSource>

Origen de datos enumerable.An enumerable data source.

localInit
Func<TLocal>

Delegado de función que devuelve el estado inicial de los datos locales de cada tarea.The function delegate that returns the initial state of the local data for each task.

body
Func<TSource,ParallelLoopState,TLocal,TLocal>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

localFinally
Action<TLocal>

Delegado que realiza una acción final en el estado local de cada tarea.The delegate that performs a final action on the local state of each task.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento body es null.The body argument is null.

o bien-or- El argumento localInit es null.The localInit argument is null.

o bien-or- El argumento localFinally es null.The localFinally argument is null.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

Ejemplos

En el ejemplo siguiente se muestra cómo usar un método ForEach con estado local:The following example shows how to use a ForEach method with local state:

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

Comentarios

El delegado de body se invoca una vez para cada elemento del source Enumerable.The body delegate is invoked once for each element in the source enumerable. Se proporciona con los parámetros siguientes: el elemento actual, una instancia de ParallelLoopState que se puede usar para salir del bucle prematuramente, y algún estado local que se puede compartir entre las iteraciones que se ejecutan en el mismo subproceso.It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, and some local state that may be shared amongst iterations that execute on the same thread.

El delegado de localInit se invoca una vez para cada tarea que participa en la ejecución del bucle y devuelve el estado local inicial de cada una de esas tareas.The localInit delegate is invoked once for each task that participates in the loop's execution and returns the initial local state for each of those tasks. Estos estados iniciales se pasan al primer body invocaciones en cada tarea.These initial states are passed to the first body invocations on each task. Después, cada invocación del cuerpo subsiguiente devuelve un valor de estado posiblemente modificado que se pasa a la invocación del cuerpo siguiente.Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Por último, la última invocación del cuerpo en cada tarea devuelve un valor de estado que se pasa al delegado localFinally.Finally, the last body invocation on each task returns a state value that is passed to the localFinally delegate. El delegado de localFinally se invoca una vez por subproceso para realizar una acción final en el estado local de cada tarea.The localFinally delegate is invoked once per thread to perform a final action on each task's local state. Este delegado se puede invocar simultáneamente en varias tareas; por lo tanto, debe sincronizar el acceso a las variables compartidas.This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

El método Parallel.ForEach puede usar más tareas que los subprocesos durante su ejecución, ya que las tareas existentes se completan y se reemplazan por nuevas tareas.The Parallel.ForEach method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. Esto proporciona al objeto de TaskScheduler subyacente la oportunidad de agregar, cambiar o quitar los subprocesos que dan servicio al bucle.This gives the underlying TaskScheduler object the chance to add, change, or remove threads that service the loop.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en IEnumerable donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on an IEnumerable in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los datos del origen.The type of the data in the source.

TLocal

Tipo de los datos locales de subprocesos.The type of the thread-local data.

Parámetros

source
IEnumerable<TSource>

Origen de datos enumerable.An enumerable data source.

localInit
Func<TLocal>

Delegado de función que devuelve el estado inicial de los datos locales de cada tarea.The function delegate that returns the initial state of the local data for each task.

body
Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

localFinally
Action<TLocal>

Delegado que realiza una acción final en el estado local de cada tarea.The delegate that performs a final action on the local state of each task.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento body es null.The body argument is null.

o bien-or- El argumento localInit es null.The localInit argument is null.

o bien-or- El argumento localFinally es null.The localFinally argument is null.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

Comentarios

El delegado de body se invoca una vez para cada elemento del source Enumerable.The body delegate is invoked once for each element in the source enumerable. Se proporciona con los parámetros siguientes: el elemento actual, una instancia de ParallelLoopState que se puede usar para salir del bucle prematuramente, el índice del elemento actual (Int64) y algún estado local que se puede compartir entre las iteraciones que se ejecutan en el mismo subproceso.It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, the current element's index (Int64), and some local state that may be shared amongst iterations that execute on the same thread.

El delegado de localInit se invoca una vez para cada tarea que participa en la ejecución del bucle y devuelve el estado local inicial de cada una de esas tareas.The localInit delegate is invoked once for each task that participates in the loop's execution and returns the initial local state for each of those tasks. Estos estados iniciales se pasan al primer body invocaciones en cada tarea.These initial states are passed to the first body invocations on each task. Después, cada invocación del cuerpo subsiguiente devuelve un valor de estado posiblemente modificado que se pasa a la invocación del cuerpo siguiente.Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Por último, la última invocación del cuerpo en cada tarea devuelve un valor de estado que se pasa al delegado localFinally.Finally, the last body invocation on each task returns a state value that is passed to the localFinally delegate. El delegado de localFinally se invoca una vez por tarea para realizar una acción final en el estado local de cada tarea.The localFinally delegate is invoked once per task to perform a final action on each task's local state. Este delegado se puede invocar simultáneamente en varias tareas; por lo tanto, debe sincronizar el acceso a las variables compartidas.This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

El método Parallel.ForEach puede usar más tareas que los subprocesos durante su ejecución, ya que las tareas existentes se completan y se reemplazan por nuevas tareas.The Parallel.ForEach method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. Esto proporciona al objeto de TaskScheduler subyacente la oportunidad de agregar, cambiar o quitar los subprocesos que dan servicio al bucle.This gives the underlying TaskScheduler object the chance to add, change, or remove threads that service the loop.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en Partitioner donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on a Partitioner in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los elementos de source.The type of the elements in source.

TLocal

Tipo de los datos locales de subprocesos.The type of the thread-local data.

Parámetros

source
Partitioner<TSource>

Particionador que contiene el origen de datos original.The partitioner that contains the original data source.

localInit
Func<TLocal>

Delegado de función que devuelve el estado inicial de los datos locales de cada tarea.The function delegate that returns the initial state of the local data for each task.

body
Func<TSource,ParallelLoopState,TLocal,TLocal>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

localFinally
Action<TLocal>

Delegado que realiza una acción final en el estado local de cada tarea.The delegate that performs a final action on the local state of each task.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento body es null.The body argument is null.

o bien-or- El argumento localInit es null.The localInit argument is null.

o bien-or- El argumento localFinally es null.The localFinally argument is null.

La propiedad SupportsDynamicPartitions de sourcePartitioner devuelve false o el particionador devuelve particiones null.The SupportsDynamicPartitions property in the sourcePartitioner returns false or the partitioner returns null partitions.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

Comentarios

Esta sobrecarga se proporciona para los escenarios en los que desea invalidar el esquema de partición predeterminado.This overload is provided for scenarios where you want to override the default partitioning scheme. Por ejemplo, los cuerpos de bucle pequeños podrían beneficiarse de la creación de particiones del intervalo.For example, small loop bodies might benefit from partitioning the range. El método ForEach espera que los particionadores personalizados admitan la creación de particiones dinámicas.The ForEach method expects custom partitioners to support dynamic partitioning. Para obtener más información, consulte particionadores personalizados para PLINQ y TPL y Cómo: implementar particiones dinámicas.For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

El delegado de localInit se invoca una vez para cada subproceso que participa en la ejecución del bucle y devuelve el estado local inicial de cada una de esas tareas.The localInit delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those tasks. Estos estados iniciales se pasan al primer body invocaciones en cada tarea.These initial states are passed to the first body invocations on each task. Después, cada invocación del cuerpo subsiguiente devuelve un valor de estado posiblemente modificado que se pasa a la invocación del cuerpo siguiente.Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Por último, la última invocación del cuerpo en cada tarea devuelve un valor de estado que se pasa al delegado localFinally.Finally, the last body invocation on each task returns a state value that is passed to the localFinally delegate. El delegado de localFinally se invoca una vez por tarea para realizar una acción final en el estado local de cada tarea.The localFinally delegate is invoked once per task to perform a final action on each task's local state. Este delegado se puede invocar simultáneamente en varias tareas; por lo tanto, debe sincronizar el acceso a las variables compartidas.This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

El método Parallel.ForEach puede usar más tareas que los subprocesos durante su ejecución, ya que las tareas existentes se completan y se reemplazan por nuevas tareas.The Parallel.ForEach method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. Esto proporciona al objeto de TaskScheduler subyacente la oportunidad de agregar, cambiar o quitar los subprocesos que dan servicio al bucle.This gives the underlying TaskScheduler object the chance to add, change, or remove threads that service the loop.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) con datos locales del subproceso en OrderablePartitioner<TSource> donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with thread-local data on a OrderablePartitioner<TSource> in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los elementos de source.The type of the elements in source.

TLocal

Tipo de los datos locales de subprocesos.The type of the thread-local data.

Parámetros

source
OrderablePartitioner<TSource>

Particionador ordenable que contiene el origen de datos original.The orderable partitioner that contains the original data source.

localInit
Func<TLocal>

Delegado de función que devuelve el estado inicial de los datos locales de cada tarea.The function delegate that returns the initial state of the local data for each task.

body
Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

localFinally
Action<TLocal>

Delegado que realiza una acción final en el estado local de cada tarea.The delegate that performs a final action on the local state of each task.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento body es null.The body argument is null.

o bien-or- El argumento localInit es null.The localInit argument is null.

o bien-or- El argumento localFinally es null.The localFinally argument is null.

La propiedad SupportsDynamicPartitions de sourcePartitioner devuelve false o el particionador devuelve particiones null.The SupportsDynamicPartitions property in the sourcePartitioner returns false or the partitioner returns null partitions.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

Comentarios

Esta sobrecarga se proporciona para los escenarios en los que desea invalidar el esquema de partición predeterminado.This overload is provided for scenarios where you want to override the default partitioning scheme. Por ejemplo, los cuerpos de bucle pequeños podrían beneficiarse de la creación de particiones del intervalo.For example, small loop bodies might benefit from partitioning the range. El método ForEach espera que los particionadores personalizados admitan la creación de particiones dinámicas.The ForEach method expects custom partitioners to support dynamic partitioning. Para obtener más información, consulte particionadores personalizados para PLINQ y TPL y Cómo: implementar particiones dinámicas.For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

El delegado de localInit se invoca una vez para cada tarea que participa en la ejecución del bucle y devuelve el estado local inicial de cada una de esas tareas.The localInit delegate is invoked once for each task that participates in the loop's execution and returns the initial local state for each of those tasks. Estos estados iniciales se pasan al primer body invocaciones en cada tarea.These initial states are passed to the first body invocations on each task. Después, cada invocación del cuerpo subsiguiente devuelve un valor de estado posiblemente modificado que se pasa a la invocación del cuerpo siguiente.Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Por último, la última invocación del cuerpo en cada tarea devuelve un valor de estado que se pasa al delegado localFinally.Finally, the last body invocation on each task returns a state value that is passed to the localFinally delegate. El delegado de localFinally se invoca una vez por tarea para realizar una acción final en el estado local de cada tarea.The localFinally delegate is invoked once per task to perform a final action on each task's local state. Este delegado se puede invocar simultáneamente en varias tareas; por lo tanto, debe sincronizar el acceso a las variables compartidas.This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

El método Parallel.ForEach puede usar más tareas que los subprocesos durante su ejecución, ya que las tareas existentes se completan y se reemplazan por nuevas tareas.The Parallel.ForEach method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. Esto proporciona al objeto de TaskScheduler subyacente la oportunidad de agregar, cambiar o quitar los subprocesos que dan servicio al bucle.This gives the underlying TaskScheduler object the chance to add, change, or remove threads that service the loop.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) en IEnumerable donde se pueden ejecutar iteraciones en paralelo y configurar las opciones de bucle.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel and loop options can be configured.

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

Parámetros de tipo

TSource

Tipo de los datos del origen.The type of the data in the source.

Parámetros

source
IEnumerable<TSource>

Origen de datos enumerable.An enumerable data source.

parallelOptions
ParallelOptions

Objeto que configura el comportamiento de esta operación.An object that configures the behavior of this operation.

body
Action<TSource>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

CancellationToken en el argumento parallelOptions se cancelaThe CancellationToken in the parallelOptions argument is canceled

El argumento source es null.The source argument is null.

o bien-or- El argumento parallelOptions es null.The parallelOptions argument is null.

o bien-or- El argumento body es null.The body argument is null.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

El objeto CancellationTokenSource asociado a CancellationToken en el parallelOptions se ha desechado.The CancellationTokenSource associated with the CancellationToken in the parallelOptions has been disposed.

Comentarios

El delegado de body se invoca una vez para cada elemento del source Enumerable.The body delegate is invoked once for each element in the source enumerable. Se proporciona con el elemento actual como parámetro.It is provided with the current element as a parameter.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) en IEnumerable donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los datos del origen.The type of the data in the source.

Parámetros

source
IEnumerable<TSource>

Origen de datos enumerable.An enumerable data source.

parallelOptions
ParallelOptions

Objeto que configura el comportamiento de esta operación.An object that configures the behavior of this operation.

body
Action<TSource,ParallelLoopState>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

CancellationToken en el argumento parallelOptions se cancelaThe CancellationToken in the parallelOptions argument is canceled

El argumento source es null.The source argument is null.

o bien-or- El argumento parallelOptions es null.The parallelOptions argument is null.

o bien-or- El argumento body es null.The body argument is null.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

El objeto CancellationTokenSource asociado a CancellationToken en el parallelOptions se ha desechado.The CancellationTokenSource associated with the CancellationToken in the parallelOptions has been disposed.

Comentarios

El delegado de body se invoca una vez para cada elemento del source Enumerable.The body delegate is invoked once for each element in the source enumerable. Se proporciona con los parámetros siguientes: el elemento actual y una instancia de ParallelLoopState que se puede usar para salir del bucle prematuramente.It is provided with the following parameters: the current element, and a ParallelLoopState instance that may be used to break out of the loop prematurely.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) en IEnumerable donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los datos del origen.The type of the data in the source.

Parámetros

source
IEnumerable<TSource>

Origen de datos enumerable.An enumerable data source.

body
Action<TSource,ParallelLoopState>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento body es null.The body argument is null.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

Comentarios

El delegado de body se invoca una vez para cada elemento del source Enumerable.The body delegate is invoked once for each element in the source enumerable. Se proporciona con los parámetros siguientes: el elemento actual y una instancia de ParallelLoopState que se puede usar para salir del bucle prematuramente.It is provided with the following parameters: the current element, and a ParallelLoopState instance that may be used to break out of the loop prematurely.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) en Partitioner donde se pueden ejecutar iteraciones en paralelo y configurar las opciones de bucle.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel and loop options can be configured.

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

Parámetros de tipo

TSource

Tipo de los elementos de source.The type of the elements in source.

Parámetros

source
Partitioner<TSource>

Particionador que contiene el origen de datos original.The partitioner that contains the original data source.

parallelOptions
ParallelOptions

Objeto que configura el comportamiento de esta operación.An object that configures the behavior of this operation.

body
Action<TSource>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

CancellationToken en el argumento parallelOptions se cancela.The CancellationToken in the parallelOptions argument is canceled.

El objeto CancellationTokenSource asociado a CancellationToken en el parallelOptions se ha desechado.The CancellationTokenSource associated with the CancellationToken in the parallelOptions has been disposed.

El argumento source es null.The source argument is null.

o bien-or- El argumento parallelOptions es null.The parallelOptions argument is null.

o bien-or- El argumento body es null.The body argument is null.

La propiedad SupportsDynamicPartitions del particionador source devuelve false.The SupportsDynamicPartitions property in the source partitioner returns false.

o bien-or- La excepción que se produce cuando cualquier método del particionador source devuelve null.The exception that is thrown when any methods in the source partitioner return null.

Excepción que se produce para contener una excepción generada desde uno de los delegados especificados.The exception that is thrown to contain an exception thrown from one of the specified delegates.

Comentarios

Esta sobrecarga se proporciona para los escenarios en los que desea invalidar el esquema de partición predeterminado.This overload is provided for scenarios where you want to override the default partitioning scheme. Por ejemplo, los cuerpos de bucle pequeños podrían beneficiarse de la creación de particiones del intervalo.For example, small loop bodies might benefit from partitioning the range. El método Parallel.ForEach espera que los particionadores personalizados admitan la creación de particiones dinámicas.The Parallel.ForEach method expects custom partitioners to support dynamic partitioning. Para obtener más información, consulte particionadores personalizados para PLINQ y TPL y Cómo: implementar particiones dinámicas.For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) en Partitioner donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los elementos de source.The type of the elements in source.

Parámetros

source
Partitioner<TSource>

Particionador que contiene el origen de datos original.The partitioner that contains the original data source.

parallelOptions
ParallelOptions

Objeto que configura el comportamiento de esta operación.An object that configures the behavior of this operation.

body
Action<TSource,ParallelLoopState>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

CancellationToken en el argumento parallelOptions se cancela.The CancellationToken in the parallelOptions argument is canceled.

El objeto CancellationTokenSource asociado a CancellationToken en el parallelOptions se ha desechado.The CancellationTokenSource associated with the CancellationToken in the parallelOptions has been disposed.

El argumento source es null.The source argument is null.

o bien-or- El argumento parallelOptions es null.The parallelOptions argument is null.

o bien-or- El argumento body es null.The body argument is null.

La propiedad SupportsDynamicPartitions del particionador source devuelve false.The SupportsDynamicPartitions property in the source partitioner returns false.

o bien-or- La excepción que se produce cuando cualquier método del particionador source devuelve null.The exception that is thrown when any methods in the source partitioner return null.

Excepción que se produce para contener una excepción generada desde uno de los delegados especificados.The exception that is thrown to contain an exception thrown from one of the specified delegates.

Comentarios

Esta sobrecarga se proporciona para los escenarios en los que desea invalidar el esquema de partición predeterminado.This overload is provided for scenarios where you want to override the default partitioning scheme. Por ejemplo, los cuerpos de bucle pequeños podrían beneficiarse de la creación de particiones del intervalo.For example, small loop bodies might benefit from partitioning the range. El método Parallel.ForEach espera que los particionadores personalizados admitan la creación de particiones dinámicas.The Parallel.ForEach method expects custom partitioners to support dynamic partitioning. Para obtener más información, consulte particionadores personalizados para PLINQ y TPL y Cómo: implementar particiones dinámicas.For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) en OrderablePartitioner<TSource> donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on a OrderablePartitioner<TSource> in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los elementos de source.The type of the elements in source.

Parámetros

source
OrderablePartitioner<TSource>

Particionador ordenable que contiene el origen de datos original.The orderable partitioner that contains the original data source.

parallelOptions
ParallelOptions

Objeto que configura el comportamiento de esta operación.An object that configures the behavior of this operation.

body
Action<TSource,ParallelLoopState,Int64>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

CancellationToken en el argumento parallelOptions se cancelaThe CancellationToken in the parallelOptions argument is canceled

El argumento source es null.The source argument is null.

o bien-or- El argumento parallelOptions es null.The parallelOptions argument is null.

o bien-or- El argumento body es null.The body argument is null.

El objeto CancellationTokenSource asociado a CancellationToken en el parallelOptions se ha desechado.The CancellationTokenSource associated with the CancellationToken in the parallelOptions has been disposed.

La propiedad SupportsDynamicPartitions del particionador ordenable source devuelve false.The SupportsDynamicPartitions property in the source orderable partitioner returns false.

o bien-or- La propiedad KeysNormalized del particionador ordenable source devuelve false.The KeysNormalized property in the source orderable partitioner returns false.

o bien-or- La excepción que se produce cuando cualquier método del particionador ordenable source devuelve null.The exception that is thrown when any methods in the source orderable partitioner return null.

Excepción que se produce para contener una excepción generada desde uno de los delegados especificados.The exception that is thrown to contain an exception thrown from one of the specified delegates.

Comentarios

Esta sobrecarga se proporciona para los escenarios en los que desea invalidar el esquema de partición predeterminado.This overload is provided for scenarios where you want to override the default partitioning scheme. Por ejemplo, los cuerpos de bucle pequeños podrían beneficiarse de la creación de particiones del intervalo.For example, small loop bodies might benefit from partitioning the range. El método Parallel.ForEach espera que los particionadores personalizados admitan la creación de particiones dinámicas.The Parallel.ForEach method expects custom partitioners to support dynamic partitioning. Para obtener más información, consulte particionadores personalizados para PLINQ y TPL y Cómo: implementar particiones dinámicas.For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) en IEnumerable, en la que es posible ejecutar iteraciones en paralelo.Executes a foreach (For Each in Visual Basic) operation on an IEnumerable in which iterations may run in parallel.

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

Parámetros de tipo

TSource

Tipo de los datos del origen.The type of the data in the source.

Parámetros

source
IEnumerable<TSource>

Origen de datos enumerable.An enumerable data source.

body
Action<TSource>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento body es null.The body argument is null.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

Ejemplos

En el ejemplo siguiente se usa el método ForEach<TSource>(IEnumerable<TSource>, Action<TSource>) para contar el número de vocales y caracteres que no son espacios en blanco en un archivo de texto.The following example uses the ForEach<TSource>(IEnumerable<TSource>, Action<TSource>) method to count the number of vowels and non-white-space characters in a text file. En este caso, se omite el valor de ParallelLoopResult devuelto por el método.In this case, the ParallelLoopResult value returned by the method is ignored. Tenga en cuenta que, dado que las operaciones se pueden ejecutar en paralelo, debe asegurarse de que el incremento de las variables de contador es una operación atómica y de que varios subprocesos no intentan obtener acceso a las variables de contador simultáneamente.Note that, because operations can run in parallel, you must ensure that incrementing the counter variables is an atomic operation, and that multiple threads do not attempt to access the counter variables simultaneously. Para este propósito, en el ejemplo se utiliza la instrucción lock C#(en) y la instrucción SyncLock (en Visual Basic).For this purpose, the example uses the lock statement (in C#) and the SyncLock statement (in 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

Comentarios

El delegado de body se invoca una vez para cada elemento del source Enumerable.The body delegate is invoked once for each element in the source enumerable. Se proporciona con el elemento actual como parámetro.It is provided with the current element as a parameter.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) con índices de 64 bits en IEnumerable donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes on an IEnumerable in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los datos del origen.The type of the data in the source.

Parámetros

source
IEnumerable<TSource>

Origen de datos enumerable.An enumerable data source.

body
Action<TSource,ParallelLoopState,Int64>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento body es null.The body argument is null.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

Comentarios

El delegado de body se invoca una vez para cada elemento del source Enumerable.The body delegate is invoked once for each element in the source enumerable. Se proporciona con los parámetros siguientes: el elemento actual, una instancia de ParallelLoopState que se puede usar para salir del bucle prematuramente y el índice del elemento actual (Int64).It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, and the current element's index (Int64).

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) en Partitioner, en la que es posible ejecutar iteraciones en paralelo.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel.

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

Parámetros de tipo

TSource

Tipo de los elementos de source.The type of the elements in source.

Parámetros

source
Partitioner<TSource>

Particionador que contiene el origen de datos original.The partitioner that contains the original data source.

body
Action<TSource>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento body es null.The body argument is null.

La propiedad SupportsDynamicPartitions del particionador source devuelve false.The SupportsDynamicPartitions property in the source partitioner returns false.

o bien-or- La excepción que se produce cuando cualquier método del particionador source devuelve null.The exception that is thrown when any methods in the source partitioner return null.

o bien-or- El método GetPartitions(Int32) del particionador source no devuelve el número correcto de particiones.The GetPartitions(Int32) method in the source partitioner does not return the correct number of partitions.

Excepción que se produce para contener una excepción generada desde uno de los delegados especificados.The exception that is thrown to contain an exception thrown from one of the specified delegates.

Ejemplos

En el ejemplo siguiente se muestra cómo implementar un particionador de intervalo para su uso con Parallel.ForEach:The following example shows how to implement a range partitioner for use with 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

Comentarios

Esta sobrecarga se proporciona para los escenarios en los que desea invalidar el esquema de partición predeterminado.This overload is provided for scenarios where you want to override the default partitioning scheme. Por ejemplo, los cuerpos de bucle pequeños podrían beneficiarse de la creación de particiones del intervalo.For example, small loop bodies might benefit from partitioning the range. El método Parallel.ForEach espera que los particionadores personalizados admitan la creación de particiones dinámicas.The Parallel.ForEach method expects custom partitioners to support dynamic partitioning. Para obtener más información, consulte particionadores personalizados para PLINQ y TPL y Cómo: implementar particiones dinámicas.For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) en Partitioner donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on a Partitioner in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los elementos de source.The type of the elements in source.

Parámetros

source
Partitioner<TSource>

Particionador que contiene el origen de datos original.The partitioner that contains the original data source.

body
Action<TSource,ParallelLoopState>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento body es null.The body argument is null.

La propiedad SupportsDynamicPartitions del particionador source devuelve false.The SupportsDynamicPartitions property in the source partitioner returns false.

o bien-or- Un método del particionador source devuelve null.A method in the source partitioner returns null.

o bien-or- El método GetPartitions(Int32) del particionador source no devuelve el número correcto de particiones.The GetPartitions(Int32) method in the source partitioner does not return the correct number of partitions.

Excepción que se produce para contener una excepción generada desde uno de los delegados especificados.The exception that is thrown to contain an exception thrown from one of the specified delegates.

Comentarios

Esta sobrecarga se proporciona para los escenarios en los que desea invalidar el esquema de partición predeterminado.This overload is provided for scenarios where you want to override the default partitioning scheme. Por ejemplo, los cuerpos de bucle pequeños podrían beneficiarse de la creación de particiones del intervalo.For example, small loop bodies might benefit from partitioning the range. El método Parallel.ForEach espera que los particionadores personalizados admitan la creación de particiones dinámicas.The Parallel.ForEach method expects custom partitioners to support dynamic partitioning. Para obtener más información, consulte particionadores personalizados para PLINQ y TPL y Cómo: implementar particiones dinámicas.For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

Consulte también:

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

Ejecuta una operación foreach (For Each en Visual Basic) en OrderablePartitioner<TSource> donde se pueden ejecutar iteraciones en paralelo, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation on a OrderablePartitioner<TSource> in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los elementos de source.The type of the elements in source.

Parámetros

source
OrderablePartitioner<TSource>

Particionador ordenable que contiene el origen de datos original.The orderable partitioner that contains the original data source.

body
Action<TSource,ParallelLoopState,Int64>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

El argumento source es null.The source argument is null.

o bien-or- El argumento body es null.The body argument is null.

La propiedad SupportsDynamicPartitions del particionador ordenable source devuelve false.The SupportsDynamicPartitions property in the source orderable partitioner returns false.

o bien-or- La propiedad KeysNormalized del particionador ordenable de origen devuelve false.The KeysNormalized property in the source orderable partitioner returns false.

o bien-or- Cualquier método en el particionador ordenable de origen devuelve null.Any methods in the source orderable partitioner return null.

Excepción que se produce en uno de los delegados especificados.The exception thrown from one of the specified delegates.

Comentarios

Esta sobrecarga se proporciona para los escenarios en los que desea invalidar el esquema de partición predeterminado.This overload is provided for scenarios where you want to override the default partitioning scheme. Por ejemplo, los cuerpos de bucle pequeños podrían beneficiarse de la creación de particiones del intervalo.For example, small loop bodies might benefit from partitioning the range. El método Parallel.ForEach espera que los particionadores personalizados admitan la creación de particiones dinámicas.The Parallel.ForEach method expects custom partitioners to support dynamic partitioning. Para obtener más información, consulte particionadores personalizados para PLINQ y TPL y Cómo: implementar particiones dinámicas.For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

Consulte también:

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

Ejecuta una operación foreach (For Each in Visual Basic) con índices de 64 bits en IEnumerable donde se pueden ejecutar iteraciones en paralelo y configurar opciones de bucle, y el estado del bucle se puede supervisar y manipular.Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes on an IEnumerable in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

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

Parámetros de tipo

TSource

Tipo de los datos del origen.The type of the data in the source.

Parámetros

source
IEnumerable<TSource>

Origen de datos enumerable.An enumerable data source.

parallelOptions
ParallelOptions

Objeto que configura el comportamiento de esta operación.An object that configures the behavior of this operation.

body
Action<TSource,ParallelLoopState,Int64>

Delegado que se invoca una vez por cada iteración.The delegate that is invoked once per iteration.

Devoluciones

Estructura que contiene información sobre qué parte del bucle se completó.A structure that contains information about which portion of the loop completed.

Excepciones

CancellationToken en el argumento parallelOptions se cancelaThe CancellationToken in the parallelOptions argument is canceled

El argumento source es null.The source argument is null.

o bien-or- El argumento parallelOptions es null.The parallelOptions argument is null.

o bien-or- El argumento body es null.The body argument is null.

La excepción que contiene todas las excepciones individuales producidas en todos los subprocesos.The exception that contains all the individual exceptions thrown on all threads.

El objeto CancellationTokenSource asociado a CancellationToken en el parallelOptions se ha desechado.The CancellationTokenSource associated with the CancellationToken in the parallelOptions has been disposed.

Comentarios

El delegado de body se invoca una vez para cada elemento del source Enumerable.The body delegate is invoked once for each element in the source enumerable. Se proporciona con los parámetros siguientes: el elemento actual, una instancia de ParallelLoopState que se puede usar para salir del bucle prematuramente y el índice del elemento actual (Int64).It is provided with the following parameters: the current element, a ParallelLoopState instance that may be used to break out of the loop prematurely, and the current element's index (Int64).

Consulte también:

Se aplica a