Megosztás a következőn keresztül:

Tevékenység lemondása

A System.Threading.Tasks.Task és System.Threading.Tasks.Task<TResult> osztályok a lemondási tokenek használatával támogatják a lemondást. További információ: Lemondás felügyelt szálakban. A feladatosztályokban a lemondás magában foglalja a felhasználói meghatalmazott együttműködését, amely egy lemondható műveletet jelöl, valamint a lemondást kérő kód között. A sikeres lemondás során a kérő kód meghívja a CancellationTokenSource.Cancel metódust, és a felhasználói függvény időben megszakítja a műveletet. A műveletet az alábbi lehetőségek egyikével fejezheti be:

  • A meghatalmazotttól való visszatéréssel. Ez a lehetőség sok esetben elegendő. A feladatpéldány, amelyet így szakítottak meg, az TaskStatus.RanToCompletion állapotra vált, nem pedig az TaskStatus.Canceled állapotra.

  • Egy OperationCanceledException dobása és annak a tokennek az átadása, amelyen a törlést kérték. A módszer használatának elsődleges módja a ThrowIfCancellationRequested módszer használata. Az ilyen módon megszakított feladat az "Lemondva" állapotra vált, amelyet a hívókód használhat annak ellenőrzésére, hogy a feladat válaszolt-e a lemondás iránti kérésre.

Az alábbi példa a kivételt okozó tevékenységtörlés alapmintáját mutatja be:

Megjegyzés:

A jogkivonatot a rendszer átadja a felhasználó delegáltjának és a feladatpéldánynak.

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

class Program
{
    static async Task Main()
    {
        var tokenSource2 = new CancellationTokenSource();
        CancellationToken ct = tokenSource2.Token;

        var task = Task.Run(() =>
        {
            // Were we already canceled?
            ct.ThrowIfCancellationRequested();

            bool moreToDo = true;
            while (moreToDo)
            {
                // Poll on this property if you have to do
                // other cleanup before throwing.
                if (ct.IsCancellationRequested)
                {
                    // Clean up here, then...
                    ct.ThrowIfCancellationRequested();
                }
            }
        }, tokenSource2.Token); // Pass same token to Task.Run.

        tokenSource2.Cancel();

        // Just continue on this thread, or await with try-catch:
        try
        {
            await task;
        }
        catch (OperationCanceledException e)
        {
            Console.WriteLine($"{nameof(OperationCanceledException)} thrown with message: {e.Message}");
        }
        finally
        {
            tokenSource2.Dispose();
        }

        Console.ReadKey();
    }
}

Imports System.Threading
Imports System.Threading.Tasks

Module Test
    Sub Main()
        Dim tokenSource2 As New CancellationTokenSource()
        Dim ct As CancellationToken = tokenSource2.Token

        Dim t2 = Task.Factory.StartNew(Sub()
                                           ' Were we already canceled?
                                           ct.ThrowIfCancellationRequested()

                                           Dim moreToDo As Boolean = True
                                           While moreToDo = True
                                               ' Poll on this property if you have to do
                                               ' other cleanup before throwing.
                                               If ct.IsCancellationRequested Then

                                                   ' Clean up here, then...
                                                   ct.ThrowIfCancellationRequested()
                                               End If

                                           End While
                                       End Sub _
        , tokenSource2.Token) ' Pass same token to StartNew.

        ' Cancel the task.
        tokenSource2.Cancel()

        ' Just continue on this thread, or Wait/WaitAll with try-catch:
        Try
            t2.Wait()

        Catch e As AggregateException

            For Each item In e.InnerExceptions
                Console.WriteLine(e.Message & " " & item.Message)
            Next
        Finally
            tokenSource2.Dispose()
        End Try

        Console.ReadKey()
    End Sub
End Module

Egy teljes példáért lásd: Feladat megszakítása és gyermekei.

Amikor egy feladatpéldány megfigyel egy felhasználói kód által dobott OperationCanceledException kivételt, összehasonlítja a kivétel azonosítóját a társított azonosítóval (amely a feladatot létrehozó API-nak lett átadva). Ha a jogkivonatok megegyeznek, és a jogkivonat IsCancellationRequested tulajdonsága visszaadja true, a feladat ezt úgy értelmezi, mint a lemondást, és áttér a Lemondott állapotra. Ha nem használ Wait vagy WaitAll módszert a feladatra való várakozáshoz, akkor a feladat csak az állapotát Canceled állítja be.

Ha egy olyan feladatra vár, amely az Mégse állapotba kerül, egy System.Threading.Tasks.TaskCanceledException kivétel (ami egy AggregateException kivételbe van csomagolva) kerül feldobásra. Ez a kivétel a hibás helyzet helyett a sikeres lemondást jelzi. Ezért a feladat Exception tulajdonsága visszaadja null.

Ha a jogkivonat tulajdonsága IsCancellationRequested visszaadja false, vagy ha a kivétel jogkivonata nem egyezik meg a Feladat jogkivonatával, a OperationCanceledException-t a rendszer normál kivételként kezeli, így a Feladat hibás állapotba vált. Az egyéb kivételek jelenléte azt is eredményezi, hogy a tevékenység hibás állapotba vált. A tulajdonságban Status lekérheti a befejezett tevékenység állapotát.

Előfordulhat, hogy egy feladat a lemondás kérése után is feldolgoz bizonyos elemeket.

Lásd még

  • Last updated on