Partager via


Parallel Classe

Définition

Fournit une prise en charge pour les boucles et les régions parallèles.

public ref class Parallel abstract sealed
public static class Parallel
type Parallel = class
Public Class Parallel
Héritage
Parallel

Exemples

Cet exemple illustre plusieurs approches pour implémenter une boucle parallèle à l’aide de plusieurs constructions de langage.

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

Remarques

La Parallel classe fournit des remplacements parallèles de données basés sur la bibliothèque pour les opérations courantes telles que les boucles for, pour chaque boucle et l’exécution d’un ensemble d’instructions.

Méthodes

For(Int32, Int32, Action<Int32,ParallelLoopState>)

Exécute une boucle for dans laquelle les itérations peuvent s’exécuter en parallèle et l’état de la boucle peut être supervisé et manipulé.

For(Int32, Int32, Action<Int32>)

Exécute une boucle for dans laquelle des itérations peuvent s’exécuter en parallèle.

For(Int32, Int32, ParallelOptions, Action<Int32,ParallelLoopState>)

Exécute une boucle for dans laquelle les itérations peuvent s’exécuter en parallèle, les options de la boucle peuvent être configurées et l’état de la boucle peut être supervisé et manipulé.

For(Int32, Int32, ParallelOptions, Action<Int32>)

Exécute une boucle for dans laquelle les itérations peuvent s’exécuter en parallèle et les options de la boucle peuvent être configurées.

For(Int64, Int64, Action<Int64,ParallelLoopState>)

Exécute une boucle for avec des index 64 bits dans laquelle les itérations peuvent s’exécuter en parallèle et l’état de la boucle peut être supervisé et manipulé.

For(Int64, Int64, Action<Int64>)

Exécute une boucle for avec des index 64 bits dans laquelle les itérations peuvent s’exécuter en parallèle.

For(Int64, Int64, ParallelOptions, Action<Int64,ParallelLoopState>)

Exécute une boucle for avec des index 64 bits dans laquelle les itérations peuvent s’exécuter en parallèle, les options de la boucle peuvent être configurées et l’état de la boucle peut être supervisé et manipulé.

For(Int64, Int64, ParallelOptions, Action<Int64>)

Exécute une boucle for avec des index 64 bits dans laquelle les itérations peuvent s’exécuter en parallèle et les options de la boucle peuvent être configurées.

For<TLocal>(Int32, Int32, Func<TLocal>, Func<Int32,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Exécute une boucle for avec des données locales de thread dans laquelle les itérations peuvent s’exécuter en parallèle et l’état de la boucle peut être supervisé et manipulé.

For<TLocal>(Int32, Int32, ParallelOptions, Func<TLocal>, Func<Int32,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Exécute une boucle for avec des données locales de thread dans laquelle les itérations peuvent s’exécuter en parallèle, les options de la boucle peuvent être configurées et l’état de la boucle peut être supervisé et manipulé.

For<TLocal>(Int64, Int64, Func<TLocal>, Func<Int64,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Exécute une boucle for avec des index 64 bits et des données locales de thread dans laquelle les itérations peuvent s’exécuter en parallèle et l’état de la boucle peut être supervisé et manipulé.

For<TLocal>(Int64, Int64, ParallelOptions, Func<TLocal>, Func<Int64,ParallelLoopState,TLocal,TLocal>, Action<TLocal>)

Exécute une boucle for avec des index 64 bits et des données locales de thread dans laquelle les itérations peuvent s’exécuter en parallèle, les options de la boucle peuvent être configurées et l’état de la boucle peut être supervisé et manipulé.

ForAsync<T>(T, T, CancellationToken, Func<T,CancellationToken,ValueTask>)

Exécute une boucle for dans laquelle les itérations peuvent s’exécuter en parallèle.

ForAsync<T>(T, T, Func<T,CancellationToken,ValueTask>)

Exécute une boucle for dans laquelle les itérations peuvent s’exécuter en parallèle.

ForAsync<T>(T, T, ParallelOptions, Func<T,CancellationToken,ValueTask>)

Exécute une boucle for dans laquelle les itérations peuvent s’exécuter en parallèle.

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

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread et des index 64 bits sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur IEnumerable dans laquelle les itérations peuvent s’exécuter en parallèle, les options de la boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur OrderablePartitioner<TSource> dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une foreach opération (For Each en Visual Basic) avec des index 64 bits et avec des données locales de thread sur un OrderablePartitioner<TSource> dans lequel les itérations peuvent s’exécuter en parallèle, les options de boucle peuvent être configurées et l’état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) avec des données locales de thread sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) avec des index 64 bits sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.

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

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

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

Exécute une opération foreach (For Each en Visual Basic) avec des index 64 bits sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle, les options de boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) sur IEnumerable dans laquelle les itérations peuvent s'exécuter en parallèle et les options de la boucle peuvent être configurées.

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

Exécute une opération foreach (For Each en Visual Basic) sur OrderablePartitioner<TSource> dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) sur OrderablePartitioner<TSource> dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle et l'état de la boucle peut être surveillé et manipulé.

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

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

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

Exécute une opération foreach (For Each en Visual Basic) sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle, les options de la boucle peuvent être configurées et l'état de la boucle peut être surveillé et manipulé.

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

Exécute une opération foreach (For Each en Visual Basic) sur Partitioner dans laquelle les itérations peuvent s'exécuter en parallèle et les options de la boucle peuvent être configurées.

ForEachAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken, Func<TSource,CancellationToken,ValueTask>)

Exécute une for-each opération sur un IEnumerable<T> dans lequel des itérations peuvent s’exécuter en parallèle.

ForEachAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask>)

Exécute une for-each opération sur un IEnumerable<T> dans lequel des itérations peuvent s’exécuter en parallèle.

ForEachAsync<TSource>(IAsyncEnumerable<TSource>, ParallelOptions, Func<TSource,CancellationToken,ValueTask>)

Exécute une for-each opération sur un IEnumerable<T> dans lequel des itérations peuvent s’exécuter en parallèle.

ForEachAsync<TSource>(IEnumerable<TSource>, CancellationToken, Func<TSource,CancellationToken,ValueTask>)

Exécute une for-each opération sur un IEnumerable<T> dans lequel des itérations peuvent s’exécuter en parallèle.

ForEachAsync<TSource>(IEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask>)

Exécute une for-each opération sur un IEnumerable<T> dans lequel des itérations peuvent s’exécuter en parallèle.

ForEachAsync<TSource>(IEnumerable<TSource>, ParallelOptions, Func<TSource,CancellationToken,ValueTask>)

Exécute une for-each opération sur un IEnumerable<T> dans lequel des itérations peuvent s’exécuter en parallèle.

Invoke(Action[])

Exécute chacune des actions fournies, éventuellement en parallèle.

Invoke(ParallelOptions, Action[])

Exécute chacune des actions fournies, éventuellement en parallèle, sauf si l'opération est annulée par l'utilisateur.

S’applique à

Cohérence de thread

Tous les membres publics et protégés de Parallel sont thread-safe et peuvent être utilisés simultanément par plusieurs threads.

Voir aussi