Урок 8.13 — Асинхронность

Прежде чем погружаться в async/await, нужно чётко различать три концепции. Новички часто путают асинхронность с параллельностью — но это разные вещи.

Console.WriteLine("Начало");
Thread.Sleep(3000);  // программа замирает на 3 секунды
Console.WriteLine("Конец");  // ждало 3 секунды

Представь пиццерию с одним поваром:

В программировании есть два типа задач:

Типичные I/O-bound сценарии:

• HTTP-запросы к API
• Чтение/запись файлов
• Запросы к базе данных
• Работа с сетью
• Ожидание таймера (Task.Delay)
• WebSocket / SignalR

В C# асинхронность строится на трёх китах: async, await и Task. Давай разберёмся с каждым по порядку.

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Начало: " + DateTime.Now.TimeOfDay);

        // await — ждём, но не блокируем поток
        await DoSomethingAsync();

        Console.WriteLine("Конец: " + DateTime.Now.TimeOfDay);
    }

    static async Task DoSomethingAsync()
    {
        Console.WriteLine("  Задача началась");
        await Task.Delay(2000);  // асинхронная пауза 2 секунды
        Console.WriteLine("  Задача завершилась");
    }
}

// Вывод:
// Начало: 12:00:00.000
//   Задача началась
//   Задача завершилась
// Конец: 12:00:02.000

Обрати внимание: Main тоже может быть async Task (начиная с C# 7.1). Это позволяет использовать await прямо в точке входа программы.

У async-методов есть строгие правила по возвращаемым типам. Вот три возможных варианта:

async Task SaveToFileAsync(string text) { ... }

async Task<string> DownloadAsync(string url) { ... }

Пример с возвратом значения:

using System;
using System.Threading.Tasks;
using System.Net.Http;

class Program
{
    static readonly HttpClient client = new HttpClient();

    static async Task Main()
    {
        string content = await DownloadAsync("https://example.com");
        Console.WriteLine($"Скачано {content.Length} символов");
    }

    static async Task<string> DownloadAsync(string url)
    {
        Console.WriteLine($"Скачиваю {url}...");
        string result = await client.GetStringAsync(url);
        Console.WriteLine("Готово!");
        return result;
    }
}

Когда компилятор видит async метод, он превращает его в конечный автомат (state machine). Вот что происходит под капотом:

1. Метод запускается синхронно до первого await
2. Встретив await task, компилятор проверяет: задача уже завершена? Если да — продолжаем синхронно (быстрый путь).
3. Если задача ещё выполняется — метод приостанавливается и возвращает Task в вызывающий код.
4. Поток возвращается в пул и может делать другую работу.
5. Когда задача завершается — continuation (продолжение) запускается на любом свободном потоке из пула.
6. Метод возобновляется с того же места, где остановился — все локальные переменные сохранены.

Task.Delay() — это асинхронный аналог Thread.Sleep(). Разница колоссальная:

// ПЛОХО: блокирует поток
static void BadMethod()
{
    Thread.Sleep(3000);  // поток занят 3 секунды — ничего не делает
}

// ХОРОШО: не блокирует поток
static async Task GoodMethodAsync()
{
    await Task.Delay(3000);  // поток свободен для других задач
}

// Task.Delay принимает int, TimeSpan, с CancellationToken
await Task.Delay(1000);               // 1 секунда
await Task.Delay(TimeSpan.FromMinutes(5));  // 5 минут
await Task.Delay(1000, cancellationToken);  // с возможностью отмены

Часто нужно запустить несколько асинхронных операций одновременно. Для этого есть два статических метода:

static async Task DownloadAllAsync()
{
    var httpClient = new HttpClient();

    // Запускаем несколько запросов одновременно
    Task<string> task1 = httpClient.GetStringAsync("https://example.com");
    Task<string> task2 = httpClient.GetStringAsync("https://httpbin.org/get");
    Task<string> task3 = httpClient.GetStringAsync("https://jsonplaceholder.typicode.com/posts/1");

    // Ждём, пока ВСЕ завершатся
    string[] results = await Task.WhenAll(task1, task2, task3);

    Console.WriteLine($"Размеры: {results[0].Length}, {results[1].Length}, {results[2].Length}");
    Console.WriteLine($"Всего скачано: {results.Sum(r => r.Length)} символов");
}

// Запуск параллельных задач с Task.Run (CPU-bound)
static async Task ProcessInParallelAsync()
{
    Task<int> t1 = Task.Run(() => ComputeExpensive(1_000_000));
    Task<int> t2 = Task.Run(() => ComputeExpensive(2_000_000));
    Task<int> t3 = Task.Run(() => ComputeExpensive(3_000_000));

    int[] results = await Task.WhenAll(t1, t2, t3);
    Console.WriteLine($"Результаты: {string.Join(", ", results)}");
}

static int ComputeExpensive(int n)
{
    int sum = 0;
    for (int i = 0; i < n; i++) sum += i;
    return sum;
}

WhenAny — первый завершившийся

static async Task<string> GetFirstResponseAsync()
{
    var client = new HttpClient();

    Task<string> google = client.GetStringAsync("https://google.com");
    Task<string> bing = client.GetStringAsync("https://bing.com");
    Task<string> duck  = client.GetStringAsync("https://duckduckgo.com");

    // Ждём только первый ответ
    Task<string> firstCompleted = await Task.WhenAny(google, bing, duck);

    string result = await firstCompleted;  // повторный await — получаем результат
    return result;
}

// WhenAny часто используется для:
// 1. Тайм-аутов: WhenAny(задача, Task.Delay(5000))
// 2. Первый ответ от нескольких серверов
// 3. Отмена по истечении времени

// Пример с тайм-аутом:
static async Task<string> DownloadWithTimeoutAsync(string url, int timeoutMs)
{
    using var client = new HttpClient();
    var download = client.GetStringAsync(url);
    var timeout = Task.Delay(timeoutMs);

    var completed = await Task.WhenAny(download, timeout);

    if (completed == timeout)
    {
        Console.WriteLine("Тайм-аут!");
        return null;
    }

    return await download;  // результат успешной загрузки
}

Когда ты делаешь await task, после завершения задачи продолжение (continuation) по умолчанию пытается вернуться на исходный контекст синхронизации (SynchronizationContext). В GUI-приложениях это UI-поток. В ASP.NET Core — контекст запроса. Но в библиотечном коде (не UI) возвращаться в исходный контекст не нужно — это лишние накладные расходы.

// Без ConfigureAwait — продолжение пытается вернуться в исходный контекст
await ReadFileAsync();

// С ConfigureAwait(false) — продолжение выполняется на любом потоке из пула
await ReadFileAsync().ConfigureAwait(false);

// В библиотечном коде (не UI) — всегда используй ConfigureAwait(false):
public async Task<string> ReadDataAsync()
{
    using var reader = File.OpenText("data.txt");
    string content = await reader.ReadToEndAsync().ConfigureAwait(false);
    return content;
}

// ❌ НЕ НУЖНО в UI-коде (WPF, WinForms, Blazor Server):
// Если сделать ConfigureAwait(false) в обработчике кнопки,
// то после await нельзя будет обновить UI напрямую:
private async void Button_Click(object sender, EventArgs e)
{
    string data = await DownloadAsync().ConfigureAwait(false);
    // ⚠️ Здесь уже не UI-поток!
    // textBox.Text = data;  // ❌ InvalidOperationException!
}

Не каждая задача требует async/await. Вот чёткие правила:

// ✅ ПРАВИЛЬНО: I/O-bound операция
public async Task<string> ReadFileAsync(string path)
{
    return await File.ReadAllTextAsync(path);
}

// ❌ НЕПРАВИЛЬНО: CPU-bound с async (нет выигрыша)
// Лучше: Task.Run(() => Compute())
public async Task<int> ComputeAsync(int n)
{
    return await Task.Run(() => {
        int sum = 0;
        for (int i = 0; i < n; i++) sum += i;
        return sum;
    });
}

// ✅ ПРАВИЛЬНО: CPU-bound через Task.Run (без async/await, просто Task)
public Task<int> ComputeAsync(int n)
{
    return Task.Run(() => {
        int sum = 0;
        for (int i = 0; i < n; i++) sum += i;
        return sum;
    });
}

// ❌ НЕПРАВИЛЬНО: async без await (предупреждение компилятора)
public async Task DoNothingAsync()
{
    Console.WriteLine("Это не асинхронно!");
}

// ✅ ПРАВИЛЬНО: async с await
public async Task DoSomethingAsync()
{
    await Task.Delay(100);
    Console.WriteLine("Это асинхронно!");
}

Соберём всё вместе — напишем программу, которая асинхронно загружает несколько веб-страниц и сохраняет их в файлы:

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string[] urls = {
            "https://example.com",
            "https://httpbin.org/get",
            "https://jsonplaceholder.typicode.com/posts/1",
            "https://jsonplaceholder.typicode.com/posts/2",
            "https://jsonplaceholder.typicode.com/posts/3"
        };

        Console.WriteLine($"Начинаю загрузку {urls.Length} страниц...\n");
        var watch = System.Diagnostics.Stopwatch.StartNew();

        // Синхронно (для сравнения)
        // await DownloadSyncAsync(urls);  // ~5 секунд

        // Асинхронно — все сразу
        await DownloadAllAsync(urls);  // ~1 секунда

        watch.Stop();
        Console.WriteLine($"\nВсего затрачено: {watch.ElapsedMilliseconds} мс");
    }

    static async Task DownloadAllAsync(string[] urls)
    {
        using var client = new HttpClient();
        var tasks = new Task<string>[urls.Length];

        for (int i = 0; i < urls.Length; i++)
        {
            string url = urls[i];
            int index = i;

            // Запускаем все загрузки конкурентно
            tasks[i] = DownloadAndSaveAsync(client, url, $"page_{index + 1}.html");
        }

        // Ждём все загрузки
        await Task.WhenAll(tasks);

        Console.WriteLine("\nВсе загрузки завершены!");
    }

    static async Task<string> DownloadAndSaveAsync(HttpClient client, string url, string filename)
    {
        Console.WriteLine($"  Скачиваю: {url}");

        string content = await client.GetStringAsync(url);

        await File.WriteAllTextAsync(filename, content);

        Console.WriteLine($"  Сохранено: {filename} ({content.Length} символов)");
        return content;
    }

    static async Task DownloadSyncAsync(string[] urls)
    {
        using var client = new HttpClient();

        foreach (string url in urls)
        {
            string content = await client.GetStringAsync(url);
            // Каждая следующая загрузка ждёт предыдущую
            Console.WriteLine($"  {url}: {content.Length} символов");
        }
    }
}

Это реальный паттерн, который используется в продакшене. Когда нужно загрузить много данных — запускай все задачи сразу (через Task[] или списки) и жди их через Task.WhenAll.