CancellationToken в WPF: отмена задач через CancellationTokenSource, статусы Task и OperationCanceledException

Перед нами, ещё с момента изучения Thread, стоял вопрос — как закончить поток? Thread.Stop() и Thread.Abort() давно не поддерживается, а оставлять поток открытым не хочется. Тогда что делать?

Начнем с того, что теперь, вместо потоков, мы используем асинхронное программирование и Task. Их тоже нужно отменять, так что разберем на их примере.

От bool к CancellationTokenSource #

Возьмем пример из предыдущей лекции. Там у нас был бесконечный цикл, сделанный при помощи переменной isWorking, и, если мы хотели отменить действие, мы давали ей значение false, и да, действие отменялось.

Но если я хочу иметь немного больше контроля над ситуацией (посмотреть, отменяется ли он в данный момент, уже отменился или ещё продолжается), я буду использовать CancellationToken.

Сам токен — некий enum, где хранятся состояния токена на данный момент. Чтобы мы смогли вызвать отмену токена, нам нужно создать CancellationTokenSource — источник. У каждой задачи свой источник токена.

Заменю bool переменную на CancellationTokenSource.

Вместо isWorking = false теперь я могу вызвать отмену — isWorking.Cancel().

А сам цикл я заменю на следующий вызов.

Если мы оставим всё как есть, тогда у нас появится ошибка — токен был null. Нам нужно создавать токен каждый раз перед новой задачей.

1
private async void Button_Click(object sender, RoutedEventArgs e)
2
{
3
    zagruzkaGrid.Visibility = Visibility.Visible;
4
    isWorking = new CancellationTokenSource();
5
    await Tochki();
6
    zagruzkaGrid.Visibility = Visibility.Collapsed;
7
}

Передача токена параметром #

Так и правда можно оставить код, но это будет несколько неправильно. Наш метод всё ещё зависит от большой глобальной переменной, а метод должен принимать в себя любой токен отмены в любой момент. Для этого вместо глобальной переменной мы сделаем параметр — метод будет принимать в себя токен, чтобы он не зависел ни от каких внешних факторов.

(На всякий случай, если мы не хотим всегда передавать токен, мы всегда в параметре можем написать CancellationToken token = default.)

В полном формате наш код будет выглядеть следующим образом.

1
public partial class MainWindow : Window
2
{
3
    private CancellationTokenSource isWorking;
4

5
    public MainWindow()
6
    {
7
        InitializeComponent();
8
    }
9

10
    private async void Button_Click(object sender, RoutedEventArgs e)
11
    {
12
        zagruzkaGrid.Visibility = Visibility.Visible;
13
        isWorking = new CancellationTokenSource();
14
        await Tochki(isWorking.Token);
15
        zagruzkaGrid.Visibility = Visibility.Collapsed;
16
    }
17

18
    private void Button_Click_1(object sender, RoutedEventArgs e)
19
    {
20
        isWorking.Cancel();
21
    }
22

23
    private async Task Tochki(CancellationToken token)
24
    {
25
        zagruzkaText.Text = "";
26

27
        while (!token.IsCancellationRequested)
28
        {
29
            zagruzkaText.Text += ".";
30
            await Task.Delay(50);
31
        }
32
    }
33
}

Статусы Task #

Однако, что это нам дало? Работает ведь так же, как работало с bool. А разница есть. Чтобы её увидеть, нам необходимо посмотреть статус нашего таска. Сделаем следующее.

Раз таск возвращает значение Task, значит её можно поместить в переменную. Я создам глобальную переменную типа данных Task, чтобы у меня была возможность посмотреть на этот метод отовсюду.

Вместо того, чтобы ожидать этот метод, я запишу его в переменную task. Если я записываю его в такую переменную, я не могу ожидать окончание этого метода, так как при await метод начнет возвращать void.

Чуть ниже пропишем ожидание этой задачи.

1
task = Tochki(isWorking.Token);
2
await task;

Теперь у меня есть доступ к этому методу. Воспользуюсь моей бесполезной кнопкой «Кликер». Дам ей название — statusBtn — и обработаю нажатие на неё.

Как только я нажимаю на эту кнопку, текст внутри неё будет меняться на статус моего таска при помощи task.Status.

1
private void statusBtn_Click(object sender, RoutedEventArgs e)
2
{
3
    statusBtn.Content = task.Status;
4
}

Теперь я могу посмотреть статус моей кнопки. На данный момент у меня есть 2 статуса —

WaitingForActivation — метод в данный момент идёт.

RanToCompletion — метод закончил своё выполнение. Такой статус может заработать в двух случаях — если метод правда закончил своё действие (например, у меня был не бесконечный цикл, а цикл for на 50 оборотов), и если я прервала его при помощи условия token.IsCancellationRequested. Во втором случае он также выдаст этот статус, потому что я просто прервала цикл — метод сам, без ошибок, дошел до конца.

Чтобы посмотреть третий статус, я немного видоизменю метод Tochki. Создам бесконечный цикл while(true), и если токен запросил отмену — выкину ему ошибку об отмене.

1
private async Task Tochki(CancellationToken token)
2
{
3
    zagruzkaText.Text = "";
4

5
    while (true)
6
    {
7
        if (token.IsCancellationRequested)
8
            token.ThrowIfCancellationRequested();
9

10
        zagruzkaText.Text += ".";
11
        await Task.Delay(50);
12
    }
13
}

В этом случае, мы увидим третий статус задачи.

Canceled — задача отменена принудительно, метод закончился не самостоятельно, а из-за внутренней ошибки OperationCanceledException.

Обработка OperationCanceledException #

Эту ошибку можно обработать при помощи try-catch. Скажем, при отмене, я напишу в текстовом поле слово «Отменено». Саму ошибку я буду обрабатывать там же, где ждала этот метод.

1
private async void Button_Click(object sender, RoutedEventArgs e)
2
{
3
    zagruzkaGrid.Visibility = Visibility.Visible;
4

5
    try
6
    {
7
        isWorking = new CancellationTokenSource();
8
        task = Tochki(isWorking.Token);
9
        await task;
10
    }
11
    catch (OperationCanceledException)
12
    {
13
        zagruzkaText.Text = "Отменено";
14
    }
15

16
    zagruzkaGrid.Visibility = Visibility.Collapsed;
17
}

Эти три статуса позволят мне более подробно узнать в каком состоянии сейчас находится задача. Такого функционала bool нам дать не может, только если мы начнем очень костылять и создавать эти состояния самостоятельно.

Более того, возвращаясь к потокам, при помощи CancellationToken мы можем отменять и их. Делается это при помощи той же передачи токена внутрь потока.

Зачем нужен CancellationToken #

Итак, зачем нам нужен CancellationToken?

• Мы можем элегантно отменять задачи и говорить коду, какое действие должно произойти при отмене задачи.
• С его помощью мы можем довести задачу до третьего состояния — отменено, и также обрабатывать его.
• При помощи него можно отменять потоки.

Также, чтобы не засорять наш компьютер, после работы с CancellationTokenSource и Task, не забудьте вызвать метод Dispose, который освободит все ресурсы компа, которые были затрачены на этот токен :)

Полный код примера #

MainWindow.xaml.cs — отмена через CancellationTokenSource, отслеживание статуса, обработка OperationCanceledException:

1
using System;
2
using System.Threading;
3
using System.Threading.Tasks;
4
using System.Windows;
5

6
namespace WpfApp1
7
{
8
    public partial class MainWindow : Window
9
    {
10
        private CancellationTokenSource isWorking;
11
        private Task task;
12

13
        public MainWindow()
14
        {
15
            InitializeComponent();
16
        }
17

18
        private async void Button_Click(object sender, RoutedEventArgs e)
19
        {
20
            zagruzkaGrid.Visibility = Visibility.Visible;
21

22
            try
23
            {
24
                isWorking = new CancellationTokenSource();
25
                task = Tochki(isWorking.Token);
26
                await task;
27
            }
28
            catch (OperationCanceledException)
29
            {
30
                zagruzkaText.Text = "Отменено";
31
            }
32

33
            zagruzkaGrid.Visibility = Visibility.Collapsed;
34

35
            isWorking.Dispose();
36
            task.Dispose();
37
        }
38

39
        private void Button_Click_1(object sender, RoutedEventArgs e)
40
        {
41
            isWorking.Cancel();
42
        }
43

44
        private void statusBtn_Click(object sender, RoutedEventArgs e)
45
        {
46
            statusBtn.Content = task.Status;
47
        }
48

49
        private async Task Tochki(CancellationToken token)
50
        {
51
            zagruzkaText.Text = "";
52

53
            while (true)
54
            {
55
                if (token.IsCancellationRequested)
56
                    token.ThrowIfCancellationRequested();
57

58
                zagruzkaText.Text += ".";
59
                await Task.Delay(50);
60
            }
61
        }
62
    }
63
}