Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

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

.NET Framework (current version)
 

Data di pubblicazione: novembre 2016

Esegue un'operazione foreach (For Each in Visual Basic) con dati locali del thread su un oggetto IEnumerable nel quale le iterazioni possono essere eseguite in parallelo e lo stato del ciclo può essere monitorato e modificato.

Spazio dei nomi:   System.Threading.Tasks
Assembly:  mscorlib (in mscorlib.dll)

public static ParallelLoopResult ForEach<TSource, TLocal>(
	IEnumerable<TSource> source,
	Func<TLocal> localInit,
	Func<TSource, ParallelLoopState, TLocal, TLocal> body,
	Action<TLocal> localFinally
)

Parametri

source
Type: System.Collections.Generic.IEnumerable<TSource>

Origine dati enumerabile.

localInit
Type: System.Func<TLocal>

Delegato della funzione che restituisce lo stato iniziale dei dati locali per ogni attività.

body
Type: System.Func<TSource, ParallelLoopState, TLocal, TLocal>

Delegato richiamato una volta per iterazione.

localFinally
Type: System.Action<TLocal>

Delegato che esegue un'azione finale sullo stato locale di ogni attività.

Valore restituito

Type: System.Threading.Tasks.ParallelLoopResult

Struttura che contiene informazioni sulla parte di ciclo completata.

Parametri tipo

TSource

Tipo di dati nell'origine.

TLocal

Tipo dei dati locali del thread.

Exception Condition
ArgumentNullException

Il valore dell'argomento source è null.

-oppure-

Il valore dell'argomento body è null.

-oppure-

Il valore dell'argomento localInit è null.

-oppure-

Il valore dell'argomento localFinally è null.

AggregateException

Eccezione che contiene tutte le singole eccezioni generate in tutti i thread.

Il body delegato viene richiamato una volta per ogni elemento di source enumerabile. Viene fornito con i seguenti parametri: l'elemento corrente, un ParallelLoopState istanza che può essere utilizzata per uscire dal ciclo in modo anomalo e uno stato locale che può essere condiviso fra le iterazioni che vengono eseguite sullo stesso thread.

Il localInit delegato viene richiamato una volta per ogni attività che partecipa all'esecuzione del ciclo e restituisce lo stato locale iniziale per ognuna di tali attività. Questi stati iniziali vengono passati al primo body chiamate per ogni attività. Quindi, ogni chiamata del corpo successiva restituisce un valore di stato probabilmente modificato che viene passato alla chiamata del corpo successiva. Infine, l'ultima chiamata corpo su ogni attività restituisce un valore di stato che viene passato per il localFinally delegare. Il localFinally delegato viene richiamato una volta per thread per eseguire un'azione finale sullo stato locale di ogni attività. Questo delegato può essere chiamato simultaneamente più attività; Pertanto, è necessario sincronizzare l'accesso a tutte le variabili condivise.

Il Parallel.ForEach<TSource> metodo può utilizzare più attività di thread per tutta la durata della sua esecuzione, come le attività esistenti completate e vengono sostituiti da nuove attività. In questo modo sottostante TaskScheduler oggetto la possibilità di aggiungere, modificare o rimuovere i thread che il ciclo del servizio.

Nell'esempio seguente viene illustrato come utilizzare un ForEach<TSource> metodo con lo stato locale:

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/en-us/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);
        }
    }

}

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 4.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: