Parallel Classe

Definição

Namespace:: System.Threading.Tasks

Assembly:: System.Threading.Tasks.Parallel.dll

Assemblies:: mscorlib.dll, System.Threading.Tasks.Parallel.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Fornece suporte para regiões e loops paralelos.Provides support for parallel loops and regions.

public ref class Parallel abstract sealed

public static class Parallel

type Parallel = class

Public Class Parallel

Herança: Object
Parallel

Exemplos

Este exemplo demonstra várias abordagens para implementar um loop paralelo usando construções de várias linguagens.This example demonstrates several approaches to implementing a parallel loop using multiple language constructs.

using System.Threading.Tasks;   
class Test
{
    static int N = 1000;

    static void TestMethod()
    {
        // Using a named method.
        Parallel.For(0, N, Method2);

        // Using an anonymous method.
        Parallel.For(0, N, delegate(int i)
        {
            // Do Work.
        });

        // Using a lambda expression.
        Parallel.For(0, N, i =>
        {
            // Do Work.
        });
    }

    static void Method2(int i)
    {
        // Do work.
    }
}

Imports System.Threading.Tasks

Module Module1

    Sub Main()
        Dim N As Integer = 1000

        ' Using a named method
        Parallel.For(0, N, AddressOf Method2)

        ' Using a lambda expression.
        Parallel.For(0, N, Sub(i)
                               ' Do Work
                           End Sub)
    End Sub

    Sub Method2(ByVal i As Integer)
        ' Do work.
    End Sub

End Module

Comentários

A Parallel classe fornece substituições paralelas de dados baseados em biblioteca para operações comuns, como loops for, para cada loop e execução de um conjunto de instruções.The Parallel class provides library-based data parallel replacements for common operations such as for loops, for each loops, and execution of a set of statements.

Métodos

For(Int32, Int32, Action<Int32,ParallelLoopState>)	Executa um loop `for` no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a `for` loop in which iterations may run in parallel and the state of the loop can be monitored and manipulated.
For(Int32, Int32, Action<Int32>)	Executa um loop `for` no qual as iterações podem ser executadas em paralelo.Executes a `for` loop in which iterations may run in parallel.
For(Int32, Int32, ParallelOptions, Action<Int32,ParallelLoopState>)	Executa um loop `for` no qual as iterações podem ser executadas em paralelo, as opções do loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a `for` loop in which iterations may run in parallel, loop options can be configured, and the state of the loop can be monitored and manipulated.
For(Int32, Int32, ParallelOptions, Action<Int32>)	Executa um loop `for` em que as iterações podem ser executadas em paralelo e as opções de loop podem ser configuradas.Executes a `for` loop in which iterations may run in parallel and loop options can be configured.
For(Int64, Int64, Action<Int64,ParallelLoopState>)	Executa um loop `for` com índices de 64 bits no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a `for` loop with 64-bit indexes in which iterations may run in parallel and the state of the loop can be monitored and manipulated.
For(Int64, Int64, Action<Int64>)	Executa um loop `for` com índices de 64 bits no qual as iterações podem ser executadas em paralelo.Executes a `for` loop with 64-bit indexes in which iterations may run in parallel.
For(Int64, Int64, ParallelOptions, Action<Int64,ParallelLoopState>)	Executa um loop `for` com índices de 64 bits no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado de loop pode ser monitorado e manipulado.Executes a `for` 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.
For(Int64, Int64, ParallelOptions, Action<Int64>)	Executa um loop `for` com índices de 64 bits no qual as iterações podem ser executadas em paralelo e opções de loop podem ser configuradas.Executes a `for` loop with 64-bit indexes in which iterations may run in parallel and loop options can be configured.
For<TLocal>(Int32, Int32, Func<TLocal>, Func<Int32,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Executa um loop `for` com os dados locais de thread no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a `for` loop with thread-local data in which iterations may run in parallel, and the state of the loop can be monitored and manipulated.
For<TLocal>(Int32, Int32, ParallelOptions, Func<TLocal>, Func<Int32,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Executa um loop `for` com os dados locais do thread nos quais iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a `for` 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.
For<TLocal>(Int64, Int64, Func<TLocal>, Func<Int64,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Executa um loop `for` com índices de 64 bits e dados locais de thread no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.Executes a `for` 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.
For<TLocal>(Int64, Int64, ParallelOptions, Func<TLocal>, Func<Int64,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Executa um loop `for` com índices de 64 bits e dados locais do thread nos quais iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.Executes a `for` 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.
ForEach<TSource,TLocal>(IEnumerable<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	Executa uma operação `foreach` (`For Each` no Visual Basic) com os dados de local de thread em um IEnumerable no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.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,TLocal,TLocal>, Action<TLocal>)	Executa uma operação `foreach` (`For Each` no Visual Basic) com índices de dados de local de thread em um IEnumerable, no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.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>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	Executa uma operação `foreach` (`For Each` no Visual Basic) com os dados locais de thread e índices de 64 bits em um IEnumerable, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado de loop pode ser monitorado e manipulado.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>(IEnumerable<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Executa uma operação `foreach` (`For Each` no Visual Basic) com os dados locais do thread em um IEnumerable no qual as iterações podem ser executadas em paralelo, as opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.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>(OrderablePartitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	Executa uma operação `foreach` (`For Each` no Visual Basic) com os dados locais do thread em um OrderablePartitioner<TSource>, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.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,TLocal>(OrderablePartitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,Int64,TLocal,TLocal>, Action<TLocal>)	Executa uma operação `foreach` (`For Each` no Visual Basic) com índices de 64 bits e dados locais do thread em um OrderablePartitioner<TSource>, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.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>(Partitioner<TSource>, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Executa uma operação `foreach` (`For Each` no Visual Basic) com os dados de local de thread em um Partitioner, no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.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>(Partitioner<TSource>, ParallelOptions, Func<TLocal>, Func<TSource,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)	Executa uma operação `foreach` (`For Each` no Visual Basic) com os dados locais do thread em um Partitioner, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.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>(IEnumerable<TSource>, Action<TSource,ParallelLoopState,Int64>)	Executa uma operação `foreach` (`For Each` no Visual Basic) com índices de 64 bits em uma IEnumerable na qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.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>(IEnumerable<TSource>, Action<TSource,ParallelLoopState>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em uma IEnumerable na qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.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>(IEnumerable<TSource>, Action<TSource>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em um IEnumerable no qual as iterações podem ser executadas em paralelo.Executes a `foreach` (`For Each` in Visual Basic) operation on an IEnumerable in which iterations may run in parallel.
ForEach<TSource>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em índices de 64 bits em um IEnumerable, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado de loop pode ser monitorado e manipulado.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>(IEnumerable<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em um IEnumerable, no qual iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado de loop pode ser monitorado e manipulado.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>, ParallelOptions, Action<TSource>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em um IEnumerable no qual as iterações podem ser executadas em paralelo e as opções de loop podem ser configuradas.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>(OrderablePartitioner<TSource>, Action<TSource,ParallelLoopState,Int64>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em um OrderablePartitioner<TSource>, no qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.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>(OrderablePartitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState,Int64>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em um OrderablePartitioner<TSource>, em que iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.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>(Partitioner<TSource>, Action<TSource,ParallelLoopState>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em um Partitioner, na qual as iterações podem ser executadas em paralelo e o estado do loop pode ser monitorado e manipulado.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>(Partitioner<TSource>, Action<TSource>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em um Partitioner no qual as iterações podem ser executadas em paralelo.Executes a `foreach` (`For Each` in Visual Basic) operation on a Partitioner in which iterations may run in parallel.
ForEach<TSource>(Partitioner<TSource>, ParallelOptions, Action<TSource,ParallelLoopState>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em um Partitioner, em que iterações podem ser executadas em paralelo, opções de loop podem ser configuradas e o estado do loop pode ser monitorado e manipulado.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>(Partitioner<TSource>, ParallelOptions, Action<TSource>)	Executa uma operação `foreach` (`For Each` no Visual Basic) em um Partitioner no qual as iterações podem ser executadas em paralelo e as opções de loop podem ser configuradas.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.
Invoke(Action[])	Executa cada uma das ações fornecidas, possivelmente em paralelo.Executes each of the provided actions, possibly in parallel.
Invoke(ParallelOptions, Action[])	Executa cada uma das ações fornecidas, possivelmente em paralelo, a menos que a operação seja cancelada pelo usuário.Executes each of the provided actions, possibly in parallel, unless the operation is cancelled by the user.

Aplica-se a

Acesso thread-safe

Todos os membros públicos e protegidos do Parallel são thread-safe e podem ser usados simultaneamente de vários threads.All public and protected members of Parallel are thread-safe and may be used concurrently from multiple threads.