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 Task.ContinueWith<TResult>(Func<Task, TResult>, CancellationToken, TaskContinuationOptions, TaskScheduler)

 

Data di pubblicazione: ottobre 2016

Crea una continuazione che viene eseguita in base alle opzioni di continuazione specificate e restituisce un valore. La continuazione riceve un token di annullamento e usa un'utilità di pianificazione specificata.

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

public Task<TResult> ContinueWith<TResult>(
	Func<Task, TResult> continuationFunction,
	CancellationToken cancellationToken,
	TaskContinuationOptions continuationOptions,
	TaskScheduler scheduler
)

Parametri

continuationFunction
Type: System.Func<Task, TResult>

Funzione da eseguire in base al parametro specificato continuationOptions. Durante l'esecuzione, l'attività completata verrà passata come argomento al delegato.

cancellationToken
Type: System.Threading.CancellationToken

Oggetto CancellationToken che verrà assegnato alla nuova attività di continuazione.

continuationOptions
Type: System.Threading.Tasks.TaskContinuationOptions

Opzioni relative alla pianificazione e al comportamento della continuazione. Ciò comprende criteri, ad esempio OnlyOnCanceled, nonché opzioni di esecuzione, ad esempio ExecuteSynchronously.

scheduler
Type: System.Threading.Tasks.TaskScheduler

Oggetto TaskScheduler da associare all'attività di continuazione e da usare per l'esecuzione.

Valore restituito

Type: System.Threading.Tasks.Task<TResult>

Nuovo oggetto Task<TResult> di continuazione.

Parametri tipo

TResult

Tipo del risultato prodotto dalla continuazione.

Exception Condition
ObjectDisposedException

L'interfaccia Task è stata eliminata.

-oppure-

Il CancellationTokenSource che ha creato il token è già stato eliminato.

ArgumentNullException

Il continuationFunction argomento è null.

-oppure-

Il scheduler argomento è null.

ArgumentOutOfRangeException

Il continuationOptions argomento specifica un valore valido per TaskContinuationOptions.

L'oggetto restituito Task<TResult> non verrà pianificato per l'esecuzione fino a quando non è stata completata l'attività corrente. Se i criteri specificati tramite il continuationOptions parametro non vengono soddisfatti, l'attività di continuazione verrà annullata anziché pianificata.

Nell'esempio seguente viene illustrato come utilizzare il metodo ContinueWith con opzioni di continuazione:

using System;
using System.Threading;
using System.Threading.Tasks;

class ContinuationOptionsDemo
{
    // Demonstrated features:
    //      TaskContinuationOptions
    //		Task.ContinueWith()
    // 		Task.Factory
    //		Task.Wait()
    // Expected results:
    // 		This sample demonstrates branched continuation sequences - Task+Commit or Task+Rollback.
    //      Notice that no if statements are used.
    //		The first sequence is successful - tran1 and commitTran1 are executed. rollbackTran1 is canceled.
    //		The second sequence is unsuccessful - tran2 and rollbackTran2 are executed. tran2 is faulted, and commitTran2 is canceled.
    // Documentation:
    //		http://msdn.microsoft.com/en-us/library/system.threading.tasks.taskcontinuationoptions(VS.100).aspx
    static void Main()
    {
        Action success = () => Console.WriteLine("Task={0}, Thread={1}: Begin successful transaction",
                                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        Action failure = () =>
        {
            Console.WriteLine("Task={0}, Thread={1}: Begin transaction and encounter an error",
                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
            throw new InvalidOperationException("SIMULATED EXCEPTION");
        };

        Action<Task> commit = (antecendent) => Console.WriteLine("Task={0}, Thread={1}: Commit transaction",
                                                                Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        Action<Task> rollback = (antecendent) =>
        {
            // "Observe" your antecedent's exception so as to avoid an exception
            // being thrown on the finalizer thread
            var unused = antecendent.Exception;

            Console.WriteLine("Task={0}, Thread={1}: Rollback transaction",
                  Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
        };

        // Successful transaction - Begin + Commit
        Console.WriteLine("Demonstrating a successful transaction");

        // Initial task
        // Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Task tran1 = Task.Factory.StartNew(success);

        // The following task gets scheduled only if tran1 completes successfully
        var commitTran1 = tran1.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion);

        // The following task gets scheduled only if tran1 DOES NOT complete successfully
        var rollbackTran1 = tran1.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion);

        // For demo purposes, wait for the sample to complete
        commitTran1.Wait();

        // -----------------------------------------------------------------------------------


        // Failed transaction - Begin + exception + Rollback
        Console.WriteLine("\nDemonstrating a failed transaction");

        // Initial task
        // Treated as "fire-and-forget" -- any exceptions will be cleaned up in rollback continuation
        Task tran2 = Task.Factory.StartNew(failure);

        // The following task gets scheduled only if tran2 completes successfully
        var commitTran2 = tran2.ContinueWith(commit, TaskContinuationOptions.OnlyOnRanToCompletion);

        // The following task gets scheduled only if tran2 DOES NOT complete successfully
        var rollbackTran2 = tran2.ContinueWith(rollback, TaskContinuationOptions.NotOnRanToCompletion);

        // For demo purposes, wait for the sample to complete
        rollbackTran2.Wait();
    }

}

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