mscorlib 4.0.0.0 System.Object

The class provides library-based data parallel replacements for common operations such as for loops, for each loops, and execution of a set of statements.

Provides support for parallel loops and regions.

- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the following parameters: the iteration count (), and a instance that may be used to break out of the loop prematurely.

  Calling the method informs the for operation that iterations after the current one don't have to execute. However, all iterations before the current one will still have to be executed if they haven't already.

  Therefore, calling is similar to using a break operation within a conventional for loop in a language like C#, but it is not a perfect substitute: For example, there is no guarantee that iterations after the current one will definitely not execute.

  If executing all iterations before the current one is not necessary, use the method instead of using . Calling informs the for loop that it may abandon all remaining iterations, regardless of whether they're before or after the current iteration, because all required work will have already been completed. However, as with , there are no guarantees regarding which other iterations will not execute.

  If a loop is ended prematurely, the structure that is returned will contain relevant information about the loop's completion.

  If is greater than or equal to , the method returns immediately without performing any iterations.

  Executes a for (For in Visual Basic) loop in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. The delegate that is invoked once per iteration.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the iteration count () as a parameter.

  If is greater than or equal to , the method returns immediately without performing any iterations.

  Executes a for (For in Visual Basic) loop in which iterations may run in parallel.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. The delegate that is invoked once per iteration.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the following parameters: the iteration count (), and a instance that may be used to break out of the loop prematurely.

  Calling the method informs the for operation that iterations after the current one don’t have to be executed, but all iterations before the current one do.

  Therefore, calling Break is similar to using a break operation within a conventional for loop in a language like C#, but it is not a perfect substitute: For example, there is no guarantee that iterations after the current one will definitely not execute.

  If executing all iterations before the current one is not necessary, use the method instead of using . Calling informs the for loop that it may abandon all remaining iterations, regardless of whether they're before or after the current iteration, because all required work will have already been completed. However, as with , there are no guarantees regarding which other iterations will not execute.

  If a loop is ended prematurely, the structure that is returned will contain relevant information about the loop's completion.

  If is greater than or equal to , then the method returns immediately without performing any iterations.

  Executes a for (For in Visual Basic) loop with 64-bit indexes in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

  A structure that contains information on what portion of the loop completed.

  The start index, inclusive. The end index, exclusive. The delegate that is invoked once per iteration.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the iteration count () as a parameter.

  If is greater than or equal to , the method returns immediately without performing any iterations.

  Executes a for (For in Visual Basic) loop with 64-bit indexes in which iterations may run in parallel.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. The delegate that is invoked once per iteration.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the following parameters: the iteration count (), and a instance that may be used to break out of the loop prematurely.

  If is greater than or equal to , the method returns immediately without performing any iterations.

  Executes a for (For in Visual Basic) loop in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. An object that configures the behavior of this operation. The delegate that is invoked once per iteration.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the iteration count () as a parameter.

  If is greater than or equal to , then the method returns immediately without performing any iterations.

  Executes a for (For in Visual Basic) loop in which iterations may run in parallel and loop options can be configured.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. An object that configures the behavior of this operation. The delegate that is invoked once per iteration.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the following parameters: the iteration count (), and a instance that may be used to break out of the loop prematurely.

  If is greater than or equal to , the method returns immediately without performing any iterations.

  Executes a for (For in Visual Basic) loop with 64-bit indexes in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. An object that configures the behavior of this operation. The delegate that is invoked once per iteration.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` ``

  Supports 64-bit indexes. The delegate is invoked once for each value in the iteration range (, ). It is provided with the iteration count () as a parameter.

  If is greater than or equal to , then the method returns immediately without performing any iterations.

  Executes a for (For in Visual Basic) loop with 64-bit indexes in which iterations may run in parallel and loop options can be configured.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. An object that configures the behavior of this operation. The delegate that is invoked once per iteration.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the following parameters: the iteration count (), a 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.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each task returns a state value that is passed to the delegate. The delegate is invoked once per task to perform a final action on each task's local state. This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  If is greater than or equal to , then the method returns immediately without performing any iterations.

  For an example that uses this method, see How to: Write a Parallel.For Loop That Has Thread-Local Variables.

  Executes a for (For in Visual Basic) loop with thread-local data in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the following parameters: the iteration count (), a 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 task.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each task returns a state value that is passed to the delegate. The delegate is invoked once per task to perform a final action on each task's local state. This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  If is greater than or equal to , then the method returns immediately without performing any iterations.

  For an example that uses this method, see How to: Write a Parallel.For Loop That Has Thread-Local Variables.

  Executes a for (For in Visual Basic) loop with 64-bit indexes and thread-local data in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the following parameters: the iteration count (), a 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 task.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each task returns a state value that is passed to the delegate. The delegate is invoked once per task to perform a final action on each task's local state. This delegate might be invoked concurrently on multiple threads; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  If is greater than or equal to , then the method returns immediately without performing any iterations.

  Executes a for (For in Visual Basic) loop with thread-local data in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. An object that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` `` `` ``

  The delegate is invoked once for each value in the iteration range (, ). It is provided with the following parameters: the iteration count (), a 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.

  The delegate is invoked once for each thread that participates in the loop's execution and returns the initial local state for each of those threads. These initial states are passed to the first invocations on each thread. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The delegate is invoked once per thread to perform a final action on each thread's local state. This delegate might be invoked concurrently on multiple threads; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  If is greater than or equal to , then the method returns immediately without performing any iterations.

  Executes a for (For in Visual Basic) loop with 64-bit indexes and thread-local data in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The start index, inclusive. The end index, exclusive. An object that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each thread. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each thread. The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` ``

  This overload is provided for scenarios where you want to override the default partitioning scheme. For example, small loop bodies might benefit from partitioning the range. The method expects custom partitioners to support dynamic partitioning. For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

  Executes a foreach (For Each in Visual Basic) operation on a in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The orderable partitioner that contains the original data source. The delegate that is invoked once per iteration. The type of the elements in .
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` ``

  This overload is provided for scenarios where you want to override the default partitioning scheme. For example, small loop bodies might benefit from partitioning the range. The method expects custom partitioners to support dynamic partitioning. For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

  Executes a foreach (For Each in Visual Basic) operation on a in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The partitioner that contains the original data source. The delegate that is invoked once per iteration. The type of the elements in .
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` ``

  This overload is provided for scenarios where you want to override the default partitioning scheme. For example, small loop bodies might benefit from partitioning the range. The method expects custom partitioners to support dynamic partitioning. For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

  Executes a foreach (For Each in Visual Basic) operation on a in which iterations may run in parallel.

  A structure that contains information about which portion of the loop completed.

  The partitioner that contains the original data source. The delegate that is invoked once per iteration. The type of the elements in .
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` ``

  The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, a instance that may be used to break out of the loop prematurely, and the current element's index ().

  Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes on an in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  An enumerable data source. The delegate that is invoked once per iteration. The type of the data in the source.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` ``

  The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, and a instance that may be used to break out of the loop prematurely.

  Executes a foreach (For Each in Visual Basic) operation on an in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  An enumerable data source. The delegate that is invoked once per iteration. The type of the data in the source.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` ``

  The delegate is invoked once for each element in the enumerable. It is provided with the current element as a parameter.

  Executes a foreach (For Each in Visual Basic) operation on an in which iterations may run in parallel.

  A structure that contains information about which portion of the loop completed.

  An enumerable data source. The delegate that is invoked once per iteration. The type of the data in the source.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` ``

  This overload is provided for scenarios where you want to override the default partitioning scheme. For example, small loop bodies might benefit from partitioning the range. The method expects custom partitioners to support dynamic partitioning. For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

  Executes a foreach (For Each in Visual Basic) operation on a in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The orderable partitioner that contains the original data source. An object that configures the behavior of this operation. The delegate that is invoked once per iteration. The type of the elements in .
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` ``

  This overload is provided for scenarios where you want to override the default partitioning scheme. For example, small loop bodies might benefit from partitioning the range. The method expects custom partitioners to support dynamic partitioning. For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

  Executes a foreach (For Each in Visual Basic) operation on a in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The partitioner that contains the original data source. An object that configures the behavior of this operation. The delegate that is invoked once per iteration. The type of the elements in .
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` ``

  This overload is provided for scenarios where you want to override the default partitioning scheme. For example, small loop bodies might benefit from partitioning the range. The method expects custom partitioners to support dynamic partitioning. For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

  Executes a foreach (For Each in Visual Basic) operation on a in which iterations may run in parallel and loop options can be configured.

  A structure that contains information about which portion of the loop completed.

  The partitioner that contains the original data source. An object that configures the behavior of this operation. The delegate that is invoked once per iteration. The type of the elements in .
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` ``

  The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, a instance that may be used to break out of the loop prematurely, and the current element's index ().

  Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes on an in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  An enumerable data source. An object that configures the behavior of this operation. The delegate that is invoked once per iteration. The type of the data in the source.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` ``

  The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, and a instance that may be used to break out of the loop prematurely.

  Executes a foreach (For Each in Visual Basic) operation on an in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  An enumerable data source. An object that configures the behavior of this operation. The delegate that is invoked once per iteration. The type of the data in the source.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` ``

  The delegate is invoked once for each element in the enumerable. It is provided with the current element as a parameter.

  Executes a foreach (For Each in Visual Basic) operation on an in which iterations may run in parallel and loop options can be configured.

  A structure that contains information about which portion of the loop completed.

  An enumerable data source. An object that configures the behavior of this operation. The delegate that is invoked once per iteration. The type of the data in the source.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` ``

  This overload is provided for scenarios where you want to override the default partitioning scheme. For example, small loop bodies might benefit from partitioning the range. The method expects custom partitioners to support dynamic partitioning. For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each task returns a state value that is passed to the delegate. The delegate is invoked once per task to perform a final action on each task's local state. This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  Executes a foreach (For Each in Visual Basic) operation with thread-local data on a in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The orderable partitioner that contains the original data source. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the elements in . The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` ``

  This overload is provided for scenarios where you want to override the default partitioning scheme. For example, small loop bodies might benefit from partitioning the range. The method expects custom partitioners to support dynamic partitioning. For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each task returns a state value that is passed to the delegate. The delegate is invoked once per task to perform a final action on each task's local state. This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  Executes a foreach (For Each in Visual Basic) operation with thread-local data on a in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The partitioner that contains the original data source. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the elements in . The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` ``

  The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, a instance that may be used to break out of the loop prematurely, the current element's index (), and some local state that may be shared amongst iterations that execute on the same thread.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each task returns a state value that is passed to the delegate. The delegate is invoked once per task to perform a final action on each task’s local state. This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  Executes a foreach (For Each in Visual Basic) operation with thread-local data on an in which iterations may run in parallel and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  An enumerable data source. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the data in the source. The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` ``

  The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, a 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.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each task returns a state value that is passed to the delegate. The delegate is invoked once per thread to perform a final action on each task’s local state. This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  Executes a foreach (For Each in Visual Basic) operation with thread-local data on an in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  An enumerable data source. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the data in the source. The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` `` ``

  This overload is provided for scenarios where you want to override the default partitioning scheme. For example, small loop bodies might benefit from partitioning the range. The method expects custom partitioners to support dynamic partitioning. For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each thread returns a state value that is passed to the delegate. The delegate is invoked once per task to perform a final action on each task’s local state. This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  Executes a foreach (For Each in Visual Basic) operation with 64-bit indexes and with thread-local data on a in which iterations may run in parallel , loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The orderable partitioner that contains the original data source. An object that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the elements in . The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` `` ``

  This overload is provided for scenarios where you want to override the default partitioning scheme. For example, small loop bodies might benefit from partitioning the range. The method expects custom partitioners to support dynamic partitioning. This overload is provided for scenarios with small loop bodies that might benefit from static range partitioning. Partitioners must support dynamic partitions. For more information, see Custom Partitioners for PLINQ and TPL and How to: Implement Dynamic Partitions.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each task returns a state value that is passed to the delegate. The delegate is invoked once per task to perform a final action on each task's local state. This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  Executes a foreach (For Each in Visual Basic) operation with thread-local data on a in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  The partitioner that contains the original data source. An object that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the elements in . The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` `` ``

  The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, a instance that may be used to break out of the loop prematurely, the current element's index (), and some local state that may be shared amongst iterations that execute on the same thread.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each task returns a state value that is passed to the delegate. The delegate is invoked once per thread to perform a final action on each task’s local state. This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  Executes a foreach (For Each in Visual Basic) operation with thread-local data and 64-bit indexes on an in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.

  A structure that contains information about which portion of the loop completed.

  An enumerable data source. An object that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the data in the source. The type of the thread-local data.
- Method
  4.0.0.0
  System.Threading.Tasks.ParallelLoopResult `` `` `` `` ``

  The delegate is invoked once for each element in the enumerable. It is provided with the following parameters: the current element, a 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.

  The 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. These initial states are passed to the first invocations on each task. Then, every subsequent body invocation returns a possibly modified state value that is passed to the next body invocation. Finally, the last body invocation on each task returns a state value that is passed to the delegate. The delegate is invoked once per thread to perform a final action on each task’s local state. This delegate might be invoked concurrently on multiple tasks; therefore, you must synchronize access to any shared variables.

  The method may use more tasks than threads over the lifetime of its execution, as existing tasks complete and are replaced by new tasks. This gives the underlying object the chance to add, change, or remove threads that service the loop.

  Executes a foreach (For Each in Visual Basic) operation with thread-local data on an in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated..

  A structure that contains information about which portion of the loop completed.

  An enumerable data source. An object that configures the behavior of this operation. The function delegate that returns the initial state of the local data for each task. The delegate that is invoked once per iteration. The delegate that performs a final action on the local state of each task. The type of the data in the source. The type of the thread-local data.
- Method
  4.0.0.0
  System.Void `System.ParamArray`

  This method can be used to execute a set of operations, potentially in parallel.

  No guarantees are made about the order in which the operations execute or whether they execute in parallel. This method does not return until each of the provided operations has completed, regardless of whether completion occurs due to normal or exceptional termination.

  For more information, see How to: Use Parallel.Invoke to Execute Parallel Operations.

  Executes each of the provided actions, possibly in parallel.

  An array of to execute.
- Method
  4.0.0.0
  System.Void `` `System.ParamArray`

  This method can be used to execute a set of operations, potentially in parallel. The cancellation token passed in with the structure enables the caller to cancel the entire operation. For more information, see Cancellation.

  No guarantees are made about the order in which the operations execute or whether they execute in parallel. This method does not return until each of the provided operations has completed, regardless of whether completion occurs due to normal or exceptional termination.

  For more information, see How to: Use Parallel.Invoke to Execute Parallel Operations.

  Executes each of the provided actions, possibly in parallel, unless the operation is cancelled by the user.

  An object that configures the behavior of this operation. An array of actions to execute.