Condividi tramite


Parallel.Invoke Metodo

Definizione

Esegue ognuna delle azioni fornite, eventualmente in parallelo.

Overload

Invoke(Action[])

Esegue ognuna delle azioni fornite, eventualmente in parallelo.

Invoke(ParallelOptions, Action[])

Esegue ciascuna delle azioni fornite, possibilmente in parallelo, a meno che l'operazione non venga annullata dall'utente.

Invoke(Action[])

Esegue ognuna delle azioni fornite, eventualmente in parallelo.

public:
 static void Invoke(... cli::array <Action ^> ^ actions);
public static void Invoke (params Action[] actions);
static member Invoke : Action[] -> unit
Public Shared Sub Invoke (ParamArray actions As Action())

Parametri

actions
Action[]

Matrice di Action da eseguire.

Eccezioni

Il valore dell'argomento actions è null.

Eccezione generata quando qualsiasi azione nella matrice actions genera un'eccezione.

La matrice di actions contiene un elemento null.

Esempio

In questo esempio viene illustrato come usare il Invoke metodo con altri metodi, delegati anonimi ed espressioni lambda.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

    class ParallelInvokeDemo
    {

        // Demonstrated features:
        // 		Parallel.Invoke()
        // Expected results:
        // 		The threads on which each task gets executed may be different.
        //		The thread assignments may be different in different executions.
        //		The tasks may get executed in any order.
        // Documentation:
        //		http://msdn.microsoft.com/library/dd783942(VS.100).aspx
        static void Main()
        {
            try
            {
                Parallel.Invoke(
                    BasicAction,	// Param #0 - static method
                    () =>			// Param #1 - lambda expression
                    {
                        Console.WriteLine("Method=beta, Thread={0}", Thread.CurrentThread.ManagedThreadId);
                    },
                    delegate()		// Param #2 - in-line delegate
                    {
                        Console.WriteLine("Method=gamma, Thread={0}", Thread.CurrentThread.ManagedThreadId);
                    }
                );
            }
            // 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("An action has thrown an exception. THIS WAS UNEXPECTED.\n{0}", e.InnerException.ToString());
            }
        }

        static void BasicAction()
        {
            Console.WriteLine("Method=alpha, Thread={0}", Thread.CurrentThread.ManagedThreadId);
        }
    }
Imports System.Threading
Imports System.Threading.Tasks

Module InvokeDemo

    ' Demonstrated features:
    '   Parallel.Invoke()
    ' Expected results:
    '   The threads on which each task gets executed may be different.
    '   The thread assignments may be different in different executions.
    '   The tasks may get executed in any order.
    ' Documentation:
    '   http://msdn.microsoft.com/library/dd783942(VS.100).aspx
    Private Sub Main()
        Try
            ' Param #0 - static method
            Parallel.Invoke(AddressOf BasicAction,
                            Sub()
                                ' Param #1 - lambda expression
                                Console.WriteLine("Method=beta, Thread={0}", Thread.CurrentThread.ManagedThreadId)
                            End Sub,
                            Sub()
                                ' Param #2 - in-line delegate
                                Console.WriteLine("Method=gamma, Thread={0}", Thread.CurrentThread.ManagedThreadId)
                            End Sub)
        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("An action has thrown an exception. THIS WAS UNEXPECTED." & vbLf & "{0}", e.InnerException.ToString())
        End Try
    End Sub

    Private Sub BasicAction()
        Console.WriteLine("Method=alpha, Thread={0}", Thread.CurrentThread.ManagedThreadId)
    End Sub



End Module

Commenti

Questo metodo può essere usato per eseguire un set di operazioni, potenzialmente in parallelo.

Non vengono fornite garanzie sull'ordine in cui vengono eseguite le operazioni o se vengono eseguite in parallelo. Questo metodo non restituisce fino al completamento di ognuna delle operazioni fornite, indipendentemente dal fatto che il completamento si verifichi a causa della terminazione normale o eccezionale.

Per altre informazioni, vedere Procedura: utilizzare Parallel.Invoke per eseguire operazioni in parallelo.

Si applica a

Invoke(ParallelOptions, Action[])

Esegue ciascuna delle azioni fornite, possibilmente in parallelo, a meno che l'operazione non venga annullata dall'utente.

public:
 static void Invoke(System::Threading::Tasks::ParallelOptions ^ parallelOptions, ... cli::array <Action ^> ^ actions);
public static void Invoke (System.Threading.Tasks.ParallelOptions parallelOptions, params Action[] actions);
static member Invoke : System.Threading.Tasks.ParallelOptions * Action[] -> unit
Public Shared Sub Invoke (parallelOptions As ParallelOptions, ParamArray actions As Action())

Parametri

parallelOptions
ParallelOptions

Oggetto che configura il comportamento di questa operazione.

actions
Action[]

Matrice di azioni da eseguire.

Eccezioni

L'oggetto CancellationToken nell'oggetto parallelOptions è impostato.

Il valore dell'argomento actions è null.

-oppure- Il valore dell'argomento parallelOptions è null.

Eccezione generata quando qualsiasi azione nella matrice actions genera un'eccezione.

La matrice di actions contiene un elemento null.

L'oggetto CancellationTokenSource associato all'oggetto CancellationToken nel parallelOptions è stato eliminato.

Commenti

Questo metodo può essere usato per eseguire un set di operazioni, potenzialmente in parallelo. Il token di annullamento passato con la ParallelOptions struttura consente al chiamante di annullare l'intera operazione. Per altre informazioni, vedere Annullamento nei thread gestiti.

Non vengono fornite garanzie sull'ordine in cui vengono eseguite le operazioni o se vengono eseguite in parallelo. Questo metodo non restituisce fino al completamento di ognuna delle operazioni fornite, indipendentemente dal fatto che il completamento si verifichi a causa della terminazione normale o eccezionale.

Per altre informazioni, vedere Procedura: utilizzare Parallel.Invoke per eseguire operazioni in parallelo.

Si applica a