Async/await и Task в WPF: отзывчивый интерфейс, await перед методом, возврат значения из Task

Мы с вами умеем создавать многопоточность через Thread, однако создавая его, мы сильно нагружаем систему — создавая 100 Thread и запуская их, мы выделяем оперативку под 100 потоков. А если мы будем использовать Task, он сам поймёт, в каком потоке его выполнять. Т.е. создавая 100 Task, они сами поймут, в каком потоке их использовать, и потоков может быть только три.

Пример из жизни: один большой проект разделён на 100 задач. Если мы для каждой задачи возьмем отдельного человека, у нас будет 100 людей, а ими сложно управлять. Будет лучше, если 100 задач будет распределено между 3 людьми, которые сами могут правильно распределить своё время — выполнить одну задачу одновременно с другой, или отложить другую задачу в приоритет другой. 100 человек на 100 задач — Thread, 100 задач на 3 человека — Task.

Интерфейс примера #

Разберем следующий код. Я создам интерфейс с 3 кнопками:

• «Кнопка, которая заблокирует мне всё» — кнопка, на которую я нажимаю и у меня запускается какой-то очень долгий процесс, который по идее, блокирует мне интерфейс. Блокировки интерфейса происходить не должно, так что мы должны это исправить. Процесс должен завершаться, как только мы нажмем отмену.
• «Я кликер» — кнопка, по которой мы будем проверять, работает ли интерфейс или нет.
• «Отмена операции» — кнопка, по нажатию на которую мы должны отменить действие, которое запустилось по нажатию на первую кнопку.

В интерфейсе также есть грид с ползунком, который показывает, что сейчас идёт какое-то действие. Этот грид называется zagruzkaGrid.

Для имитации действия я буду ставить точку в текстовое поле. Текстовое поле у меня называется zagruzkaTxt.

Для её работы у нас есть следующий код.

1
public partial class MainWindow : Window
2
{
3
    private bool 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
        await Tochki();
14
        zagruzkaGrid.Visibility = Visibility.Hidden;
15
    }
16

17
    private void Button_Click_1(object sender, RoutedEventArgs e)
18
    {
19
        isWorking = false;
20
    }
21

22
    private async Task Tochki()
23
    {
24
        isWorking = true;
25
        zagruzkaTxt.Text = "";
26

27
        while (isWorking)
28
        {
29
            zagruzkaTxt.Text += ".";
30
            await Task.Delay(50);
31
        }
32
    }
33
}

У нас есть 3 метода, 2 из которых событие, и одна глобальная переменная — isWorking.

• Метод Tochki — метод, который должен работать параллельно с интерфейсом. Чтобы он работал параллельно, он должен являться Task — задачей — поэтому вместо void мы пишем Task. Задача определяется тем, что он возвращает тип данных Task. Задача должна идти асинхронно с остальной программой, поэтому она помечена как async.
• Глобальная переменная нужна для остановки нашего метода. Если она false — метод остановится. true — заработает.
• Button_Click — метод, который будет показывать наш ползунок с загрузкой, а также запускать метод Tochki.
• Button_Click_1 — метод, который будет завершать метод Tochki, ставя значение для isWorking = false.

Task #

Разберем отдельно Task и async/await.

Task здесь существует для того, чтобы распараллелить выполнение двух задач — работу интерфейса и создание точек. В отличии от Thread, который представляет собой физический, системный поток выполнения, Task — это штука, которая по сути перепрыгивает из потока в поток, а зачастую и вовсе не находится ни в каком потоке! В результате у вас может быть всего 10 активных потоков, но тысячи Task’ов.

Внутри Task мы можем не подключаться к интерфейсу, как мы делали это в 3-й практической для слайдера через Dispatcher.Invoke или DispatcherTimer — Task сам перепрыгнет на нужный поток с окном, когда это понадобится.

Async / await #

Так как мы распараллеливаем задачи, мы должны указать, что метод должен выполняться асинхронно с основной программой — async, asynchronously. async мы пишем после модификаторов доступа — private или public.

Вы также можете заметить, что напротив некоторых методов стоит await. Он нужен для того, чтобы ожидать выполнение некоторых методов. Зачем? Представим, у нас не было бы этого await. Тогда код бы шел следующим образом.

await позволяет нам подождать, пока метод выполнится, т.е. код остановится на метод Tochki. Прогресс бар (ползунок с загрузкой) всё ещё будет отображаться, т.к. код дойдет до момента его выключения только когда метод с точками закончится, т.е. когда мы нажмем на кнопку «Отмена операции».

await не заставляет метод работать в том же потоке, мы всё ещё можем использовать интерфейс, он всего лишь заставляет код подождать, пока метод закончится.

await пишется перед методом, который мы хотим подождать. Если в методе есть await, метод должен быть помечен как async.

Возвращаемые значения из Task #

Также, главным преимуществом у Task является то, что он может возвращать значения. Чтобы вернуть значения из Task, их нужно указать в угловых скобках после Task. Скажем, что по окончанию этого метода я хочу вернуть текст «завершено!». Вся логика возвращения значения будет такая же, как и у обычных методов.

1
private async Task<string> Tochki()
2
{
3
    isWorking = true;
4
    zagruzkaTxt.Text = "";
5

6
    while (isWorking)
7
    {
8
        zagruzkaTxt.Text += ".";
9
        await Task.Delay(50);
10
    }
11

12
    return "завершено!";
13
}

Чтобы получить значение из метода, нам опять же нужно записать его в переменную, например, result. Получившееся значение помещу в текстовое поле, к остальным точкам. Так как я хочу дождаться, пока код дойдет до конца метода Tochki, мы его ждем при помощи await. Если бы не ждал, результата бы не было.

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

5
    string result = await Tochki();
6
    zagruzkaTxt.Text += result;
7

8
    zagruzkaGrid.Visibility = Visibility.Hidden;
9
}

Результат будет следующим. Таким образом, мы можем возвращать любой тип данных.

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

MainWindow.xaml — три кнопки и блок с индикатором загрузки:

1
<Window x:Class="WpfApp1.MainWindow"
2
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
3
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
4
        Title="MainWindow" Height="300" Width="540">
5
    <Grid>
6
        <Grid.RowDefinitions>
7
            <RowDefinition/>
8
            <RowDefinition/>
9
            <RowDefinition Height="Auto"/>
10
        </Grid.RowDefinitions>
11
        <Grid.ColumnDefinitions>
12
            <ColumnDefinition/>
13
            <ColumnDefinition/>
14
        </Grid.ColumnDefinitions>
15

16
        <Button Content="отмена операции" Background="#1F3F8F" Foreground="White"
17
                Margin="10" Click="Button_Click_1"/>
18
        <Button Grid.Row="1" Content="я кликер" Background="#0A8A7B" Foreground="White"
19
                Margin="10"/>
20
        <TextBlock Grid.Column="1" Grid.RowSpan="2" x:Name="zagruzkaTxt"
21
                   VerticalAlignment="Center" Margin="10"/>
22

23
        <Grid Grid.Row="2" Grid.ColumnSpan="2" x:Name="zagruzkaGrid"
24
              Visibility="Hidden" Background="#0A8A7B">
25
            <ProgressBar IsIndeterminate="True" Height="6" Margin="20,0"/>
26
        </Grid>
27
        <Button Grid.Row="2" Grid.ColumnSpan="2" Content="кнопка которая заблокирует мне всё"
28
                Background="#0A8A7B" Foreground="White" Margin="10" Click="Button_Click"/>
29
    </Grid>
30
</Window>

MainWindow.xaml.cs — async/await с Task<string> и кнопкой отмены:

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

4
namespace WpfApp1
5
{
6
    public partial class MainWindow : Window
7
    {
8
        private bool isWorking;
9

10
        public MainWindow()
11
        {
12
            InitializeComponent();
13
        }
14

15
        private async void Button_Click(object sender, RoutedEventArgs e)
16
        {
17
            zagruzkaGrid.Visibility = Visibility.Visible;
18

19
            string result = await Tochki();
20
            zagruzkaTxt.Text += result;
21

22
            zagruzkaGrid.Visibility = Visibility.Hidden;
23
        }
24

25
        private void Button_Click_1(object sender, RoutedEventArgs e)
26
        {
27
            isWorking = false;
28
        }
29

30
        private async Task<string> Tochki()
31
        {
32
            isWorking = true;
33
            zagruzkaTxt.Text = "";
34

35
            while (isWorking)
36
            {
37
                zagruzkaTxt.Text += ".";
38
                await Task.Delay(50);
39
            }
40

41
            return "завершено!";
42
        }
43
    }
44
}