Async/await в C#: Асинхронное программировани­е в действии

private void Button_Click(object sender, RoutedEventArgs e)
{
    var httpClient = new HttpClient();
    var response = httpClient.GetAsync(url).Result; // Блокирующий вызов!
    var data = response.Content.ReadAsStringAsync().Result; // Еще один блок!
    textBlock.Text = data;
}

new Thread(() => {
    // Выполнение длительной операции
    var result = PerformLongOperation();
    // Обновление UI требует синхронизации
    Dispatcher.Invoke(() => DisplayResult(result));
}).Start();

ThreadPool.QueueUserWorkItem(state => {
    var result = PerformLongOperation();
    // Нужна синхронизация с UI
    Dispatcher.Invoke(() => DisplayResult(result));
});

webClient.BeginDownloadString(new Uri(url), ar => {
    var result = webClient.EndDownloadString(ar);
    // Снова нужна синхронизация
}, null);

var webClient = new WebClient();
webClient.DownloadStringCompleted += (s, e) => DisplayResult(e.Result);
webClient.DownloadStringAsync(new Uri(url));

Task.Run(() => PerformLongOperation())
    .ContinueWith(t => {
        // Всё ещё нужна синхронизация
        Dispatcher.Invoke(() => DisplayResult(t.Result));
    });

private async void Button_Click(object sender, RoutedEventArgs e)
{
    var httpClient = new HttpClient();
    var response = await httpClient.GetAsync(url);
    response.EnsureSuccessStatusCode();
    var data = await response.Content.ReadAsStringAsync();
    textBlock.Text = data;
}

// Исходный код
async Task<int> CalculateAsync()
{
    await Task.Delay(1000);
    return 42;
}
 
// Концептуальное представление того, что генерирует компилятор
Task<int> CalculateAsync()
{
    var stateMachine = new CalculateAsyncStateMachine();
    stateMachine.builder = AsyncTaskMethodBuilder<int>.Create();
    stateMachine.state = -1; // Исходное состояние
    stateMachine.MoveNext(); // Запуск автомата
    return stateMachine.builder.Task; // Возвращаем задачу
}
 
struct CalculateAsyncStateMachine
{
    public AsyncTaskMethodBuilder<int> builder;
    public int state;
    
    public void MoveNext()
    {
        int result;
        try {
            if (state == -1) {
                // Начало метода
                var delayTask = Task.Delay(1000);
                // Настраиваем продолжение и выходим
                state = 0;
                builder.AwaitUnsafeOnCompleted(ref delayTask, ref this);
                return;
            }
            else if (state == 0) {
                // Продолжение после Task.Delay
                result = 42;
                state = -2; // Финальное состояние
            }
        }
        catch (Exception ex) {
            state = -2;
            builder.SetException(ex);
            return;
        }
        
        if (state == -2) {
            builder.SetResult(result); // Устанавливаем результат
        }
    }
}

async Task UpdateDatabaseAsync()
{
    await dbConnection.OpenAsync();
    await dbCommand.ExecuteNonQueryAsync();
}

async Task<int> CountUsersAsync()
{
    await dbConnection.OpenAsync();
    var result = await dbCommand.ExecuteScalarAsync();
    return Convert.ToInt32(result);
}

async ValueTask<User> GetUserAsync(int id)
{
    // Проверяем кэш
    if (_cache.TryGetValue(id, out var user))
        return user; // Синхронное возвращение без создания Task
    
    // Если не в кэше, делаем асинхронную операцию
    user = await _dataAccess.LoadUserAsync(id);
    _cache[id] = user;
    return user;
}

async Task<string> GetDataAsync(string url)
{
    var responseTask = await httpClient.GetAsync(url);
    var data = await responseTask.Content.ReadAsStringAsync();
    return data;
}

Task<string> GetDataAsync(string url)
{
    var awaiter = httpClient.GetAsync(url).GetAwaiter();
    
    if (!awaiter.IsCompleted)
    {
        var tcs = new TaskCompletionSource<string>();
        awaiter.OnCompleted(() => {
            try {
                var responseTask = awaiter.GetResult();
                var contentAwaiter = responseTask.Content.ReadAsStringAsync().GetAwaiter();
                
                contentAwaiter.OnCompleted(() => {
                    try {
                        var data = contentAwaiter.GetResult();
                        tcs.SetResult(data);
                    }
                    catch (Exception ex) {
                        tcs.SetException(ex);
                    }
                });
            }
            catch (Exception ex) {
                tcs.SetException(ex);
            }
        });
        return tcs.Task;
    }
    
    // Синхронный путь выполнения
    var response = awaiter.GetResult();
    return response.Content.ReadAsStringAsync();
}

public interface IAwaiter : INotifyCompletion
{
    bool IsCompleted { get; }
    void OnCompleted(Action continuation);
    TResult GetResult();
}

public class CustomTask
{
    public CustomAwaiter GetAwaiter() => new CustomAwaiter();
}
 
public class CustomAwaiter : INotifyCompletion
{
    public bool IsCompleted => false;
    public void OnCompleted(Action continuation) => Task.Run(continuation);
    public void GetResult() { }
}

private Task<ApiData> _dataTask;
 
public Task<ApiData> GetApiDataAsync()
{
    if (_dataTask == null)
    {
        _dataTask = FetchApiDataAsync();
    }
    return _dataTask;
}

private Task<ApiData> _dataTask;
private readonly object _lockObj = new object();
 
public Task<ApiData> GetApiDataAsync()
{
    lock (_lockObj)
    {
        if (_dataTask == null || _dataTask.IsFaulted || _dataTask.IsCanceled)
        {
            _dataTask = FetchApiDataAsync();
        }
    }
    return _dataTask;
}

private Task<ApiData> _dataTask;
private DateTime _lastFetchTime;
private readonly TimeSpan _cacheLifetime = TimeSpan.FromMinutes(10);
private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1);
 
public async Task<ApiData> GetApiDataAsync()
{
    await _semaphore.WaitAsync();
    try
    {
        if (_dataTask == null || 
            _dataTask.IsFaulted || 
            _dataTask.IsCanceled || 
            DateTime.Now - _lastFetchTime > _cacheLifetime)
        {
            _dataTask = FetchApiDataAsync();
            _lastFetchTime = DateTime.Now;
        }
    }
    finally
    {
        _semaphore.Release();
    }
    
    return await _dataTask;
}

private Lazy<Task<ApiData>> _lazyTask = new Lazy<Task<ApiData>>(() => FetchApiDataAsync());
 
public Task<ApiData> GetApiDataAsync() => _lazyTask.Value;

private Lazy<Task<ApiData>> _lazyTask;
private DateTime _initTime;
private readonly TimeSpan _cacheLifetime = TimeSpan.FromMinutes(10);
private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1);
 
public async Task<ApiData> GetApiDataAsync()
{
    await _semaphore.WaitAsync();
    try
    {
        if (_lazyTask == null || DateTime.Now - _initTime > _cacheLifetime)
        {
            _lazyTask = new Lazy<Task<ApiData>>(() => FetchApiDataAsync());
            _initTime = DateTime.Now;
        }
    }
    finally
    {
        _semaphore.Release();
    }
    
    return await _lazyTask.Value;
}

private IMemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
private readonly string _cacheKey = "ApiDataKey";
 
public async Task<ApiData> GetApiDataAsync()
{
    if (!_cache.TryGetValue(_cacheKey, out Task<ApiData> task))
    {
        task = FetchApiDataAsync();
        var options = new MemoryCacheEntryOptions()
            .SetAbsoluteExpiration(TimeSpan.FromMinutes(10))
            .SetSlidingExpiration(TimeSpan.FromMinutes(2));
            
        _cache.Set(_cacheKey, task, options);
    }
    
    return await task;
}

// До оптимизации - каждый вызов создавал новый объект Task
public Task<int> GetValueAsync() => Task.FromResult(42);
 
// После оптимизации - используется пул предварительно созданных задач
public Task<int> GetValueAsync() => Task.FromResult(42); // Под капотом используется Task<int>.s_cachedTasks

// Упрощенная концепция
struct MoveNextRunner
{
    public IAsyncStateMachine StateMachine;
    
    public void Run()
    {
        StateMachine.MoveNext();
    }
}
 
// После выполнения метода, структура может вернуться в пул

var task = SomeAsyncMethod();
if (task.IsCompleted) 
{
    // Используем результат напрямую без настройки продолжения
    UseResult(task.Result);
}
else 
{
    // Настраиваем продолжение только если нужно ждать
    task.ContinueWith(t => UseResult(t.Result));
}

// Примерно так выглядит обработка async метода в сгенерированном коде
[CompilerGenerated]
private struct <MethodName>d__1 : IAsyncStateMachine
{
    // Реализация автомата
}

public async Task<UserProfile> GetUserProfileAsync(int userId)
{
    try
    {
        // Создаём HttpClient (в реальном проекте лучше использовать IHttpClientFactory)
        using var client = new HttpClient();
        
        // Устанавливаем базовый адрес и заголовки
        client.BaseAddress = new Uri("https://api.example.com/");
        client.DefaultRequestHeaders.Accept.Add(
            new MediaTypeWithQualityHeaderValue("application/json"));
        
        // Выполняем запрос
        var response = await client.GetAsync($"users/{userId}");
        
        // Проверяем статус
        response.EnsureSuccessStatusCode();
        
        // Читаем и десериализуем ответ
        var json = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<UserProfile>(json);
    }
    catch (HttpRequestException ex)
    {
        // Обрабатываем сетевые ошибки
        throw new ServiceException($"Ошибка при запросе профиля пользователя: {ex.Message}", ex);
    }
    catch (JsonException ex)
    {
        // Обрабатываем ошибки парсинга JSON
        throw new FormatException($"Недопустимый формат данных профиля: {ex.Message}", ex);
    }
}

public class ApiClient
{
    private readonly HttpClient _client;
    
    public ApiClient(string baseUrl, string apiKey)
    {
        _client = new HttpClient();
        _client.BaseAddress = new Uri(baseUrl);
        _client.DefaultRequestHeaders.Add("X-API-Key", apiKey);
        _client.DefaultRequestHeaders.Accept.Add(
            new MediaTypeWithQualityHeaderValue("application/json"));
    }
    
    public async Task<T> GetAsync<T>(string endpoint)
    {
        var response = await _client.GetAsync(endpoint);
        response.EnsureSuccessStatusCode();
        var json = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<T>(json);
    }
    
    public async Task<T> PostAsync<T>(string endpoint, object data)
    {
        var content = JsonSerializer.Serialize(data);
        var stringContent = new StringContent(content, Encoding.UTF8, "application/json");
        
        var response = await _client.PostAsync(endpoint, stringContent);
        response.EnsureSuccessStatusCode();
        
        var json = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<T>(json);
    }
}
 
// Использование
var apiClient = new ApiClient("https://api.example.com/", "your-api-key");
var user = await apiClient.GetAsync<UserProfile>("users/42");

public async Task<string> ReadLogFileAsync(string path)
{
    // Асинхронное чтение файла
    using var stream = new FileStream(
        path, 
        FileMode.Open, 
        FileAccess.Read, 
        FileShare.Read, 
        bufferSize: 4096, 
        useAsync: true); // Важный флаг для асинхронной работы
    
    using var reader = new StreamReader(stream);
    return await reader.ReadToEndAsync();
}
 
public async Task SaveDocumentAsync(string path, string content)
{
    // Создаём директории, если их нет
    var directory = Path.GetDirectoryName(path);
    if (!Directory.Exists(directory))
        Directory.CreateDirectory(directory);
    
    // Асинхронная запись в файл
    using var stream = new FileStream(
        path, 
        FileMode.Create, 
        FileAccess.Write, 
        FileShare.None, 
        bufferSize: 4096, 
        useAsync: true);
    
    using var writer = new StreamWriter(stream);
    await writer.WriteAsync(content);
}

public class CustomerRepository
{
    private readonly AppDbContext _context;
    
    public CustomerRepository(AppDbContext context)
    {
        _context = context;
    }
    
    public async Task<Customer> GetByIdAsync(int id)
    {
        return await _context.Customers
            .Include(c => c.Orders)
            .FirstOrDefaultAsync(c => c.Id == id);
    }
    
    public async Task<List<Customer>> GetAllActiveAsync()
    {
        return await _context.Customers
            .Where(c => c.IsActive)
            .ToListAsync();
    }
    
    public async Task<int> AddAsync(Customer customer)
    {
        _context.Customers.Add(customer);
        await _context.SaveChangesAsync();
        return customer.Id;
    }
    
    public async Task UpdateAsync(Customer customer)
    {
        _context.Entry(customer).State = EntityState.Modified;
        await _context.SaveChangesAsync();
    }
}

[ApiController]
[Route("api/[controller]")]
public class CustomersController : ControllerBase
{
    private readonly CustomerRepository _repository;
    
    public CustomersController(CustomerRepository repository)
    {
        _repository = repository;
    }
    
    [HttpGet("{id}")]
    public async Task<ActionResult<Customer>> Get(int id)
    {
        var customer = await _repository.GetByIdAsync(id);
        if (customer == null)
            return NotFound();
        
        return customer;
    }
    
    [HttpPost]
    public async Task<ActionResult<Customer>> Create(Customer customer)
    {
        await _repository.AddAsync(customer);
        
        return CreatedAtAction(
            nameof(Get), 
            new { id = customer.Id }, 
            customer);
    }
}

public class AsyncProducerConsumer<T>
{
    private readonly Channel<T> _channel;
    private readonly int _maxItems;
    
    public AsyncProducerConsumer(int capacity = 100)
    {
        _maxItems = capacity;
        _channel = Channel
            .CreateBounded<T>(new BoundedChannelOptions(capacity) 
            {
                FullMode = BoundedChannelFullMode.Wait
            });
    }
    
    public async Task ProduceAsync(T item, CancellationToken cancellationToken = default)
    {
        await _channel.Writer.WriteAsync(item, cancellationToken);
    }
    
    public async Task ProduceRangeAsync(IEnumerable<T> items, 
                                     CancellationToken cancellationToken = default)
    {
        foreach (var item in items)
        {
            await _channel.Writer.WriteAsync(item, cancellationToken);
        }
    }
    
    public async Task CompleteProducerAsync()
    {
        _channel.Writer.Complete();
    }
    
    public async Task ConsumeAsync(Func<T, Task> processor, 
                               CancellationToken cancellationToken = default)
    {
        await foreach (var item in _channel.Reader.ReadAllAsync(cancellationToken))
        {
            await processor(item);
        }
    }
    
    public async Task ConsumeParallelAsync(Func<T, Task> processor, 
                                       int maxConcurrency = 4,
                                       CancellationToken cancellationToken = default)
    {
        var tasks = new List<Task>();
        for (int i = 0; i < maxConcurrency; i++)
        {
            tasks.Add(Task.Run(async () =>
            {
                await foreach (var item in _channel.Reader.ReadAllAsync(cancellationToken))
                {
                    await processor(item);
                }
            }));
        }
        
        await Task.WhenAll(tasks);
    }
}

var pipeline = new AsyncProducerConsumer<string>(capacity: 1000);
 
// Запускаем потребителей
var consumer = pipeline.ConsumeAsync(async item => 
{
    await ProcessItemAsync(item);
});
 
// Добавляем элементы асинхронно
await pipeline.ProduceAsync("Item 1");
await pipeline.ProduceAsync("Item 2");
 
await pipeline.CompleteProducerAsync(); // Сигнализируем о завершении
await consumer; // Ожидаем завершения обработки всех данных

// Запускаем потребителей с параллельной обработкой
var consumer = pipeline.ConsumeParallelAsync(
    async item => await ProcessItemAsync(item),
    maxConcurrency: Environment.ProcessorCount
);

public async Task<string> DownloadDataWithTimeoutAsync(string url, TimeSpan timeout)
{
    // Создаем источник токенов отмены
    using var cts = new CancellationTokenSource(timeout);
    
    try
    {
        using var client = new HttpClient();
        // Передаем токен в асинхронный метод
        return await client.GetStringAsync(url, cts.Token);
    }
    catch (OperationCanceledException)
    {
        throw new TimeoutException($"Не удалось загрузить данные с {url} за {timeout.TotalSeconds} секунд");
    }
}

public async Task ProcessJobsAsync(
    IEnumerable<Job> jobs, 
    CancellationToken externalToken, 
    TimeSpan timeout)
{
    // Создаем источник с таймаутом
    using var timeoutCts = new CancellationTokenSource(timeout);
    
    // Объединяем два источника: внешний и таймаут
    using var linkedCts = CancellationTokenSource
        .CreateLinkedTokenSource(externalToken, timeoutCts.Token);
    
    var token = linkedCts.Token;
    
    foreach (var job in jobs)
    {
        // Проверяем, не запрошена ли отмена
        token.ThrowIfCancellationRequested();
        
        // Выполняем задачу и передаем объединенный токен
        await ProcessJobAsync(job, token);
    }
}

public async Task<List<SearchResult>> SearchFilesAsync(
    string rootPath, 
    string searchPattern, 
    CancellationToken cancellationToken = default)
{
    var results = new List<SearchResult>();
    
    // Проверка на отмену перед началом
    cancellationToken.ThrowIfCancellationRequested();
    
    try
    {
        var files = Directory.GetFiles(rootPath, searchPattern, SearchOption.AllDirectories);
        
        foreach (var file in files)
        {
            // Проверяем отмену в цикле
            cancellationToken.ThrowIfCancellationRequested();
            
            var content = await File.ReadAllTextAsync(file, cancellationToken);
            
            if (content.Contains(searchPattern))
            {
                results.Add(new SearchResult { FilePath = file });
            }
        }
        
        return results;
    }
    catch (OperationCanceledException)
    {
        // Пробрасываем исключение отмены дальше
        throw;
    }
    catch (Exception ex)
    {
        throw new SearchException($"Ошибка при поиске файлов: {ex.Message}", ex);
    }
}

public class DatabaseService
{
    private DatabaseConnection _connection;
    
    // Приватный конструктор предотвращает прямое создание
    private DatabaseService() { }
    
    // Фабричный метод для асинхронного создания
    public static async Task<DatabaseService> CreateAsync(string connectionString)
    {
        var service = new DatabaseService();
        await service.InitializeAsync(connectionString);
        return service;
    }
    
    private async Task InitializeAsync(string connectionString)
    {
        _connection = new DatabaseConnection(connectionString);
        await _connection.OpenAsync();
    }
    
    public async Task<Data> GetDataAsync(int id)
    {
        // Используем инициализированное соединение
        return await _connection.QueryAsync(id);
    }
}
 
// Использование:
var dbService = await DatabaseService.CreateAsync("connection-string");
var data = await dbService.GetDataAsync(42);

public class AnalyticsClient
{
    private readonly string _apiKey;
    private readonly SemaphoreSlim _initLock = new SemaphoreSlim(1, 1);
    private ApiConnection _connection;
    
    public AnalyticsClient(string apiKey)
    {
        _apiKey = apiKey;
    }
    
    private async Task EnsureInitializedAsync()
    {
        if (_connection != null)
            return;
            
        await _initLock.WaitAsync();
        try
        {
            if (_connection != null)
                return;
                
            _connection = new ApiConnection(_apiKey);
            await _connection.AuthenticateAsync();
        }
        finally
        {
            _initLock.Release();
        }
    }
    
    public async Task<AnalyticsData> GetMetricsAsync(DateTime startDate, DateTime endDate)
    {
        await EnsureInitializedAsync();
        return await _connection.QueryMetricsAsync(startDate, endDate);
    }
}

public class EmailService : IAsyncDisposable, IAsyncLifetime
{
    private readonly SmtpClient _client;
    private readonly string _username;
    private readonly string _password;
    
    public EmailService(string host, int port, string username, string password)
    {
        _client = new SmtpClient(host, port);
        _username = username;
        _password = password;
    }
    
    // Реализация IAsyncLifetime
    public async Task InitializeAsync()
    {
        await _client.ConnectAsync(_client.Host, _client.Port);
        await _client.AuthenticateAsync(_username, _password);
    }
    
    public async Task SendEmailAsync(string to, string subject, string body)
    {
        var message = new MimeMessage();
        message.To.Add(new MailboxAddress("", to));
        message.Subject = subject;
        message.Body = new TextPart("plain") { Text = body };
        
        await _client.SendAsync(message);
    }
    
    // Реализация IAsyncDisposable
    public async ValueTask DisposeAsync()
    {
        await _client.DisconnectAsync(true);
        _client.Dispose();
    }
    
    // Второй метод IAsyncLifetime
    public Task DisposeAsync() => Task.CompletedTask;
}
 
// В ASP.NET Core DI:
services.AddSingleton<EmailService>(sp => 
    new EmailService("smtp.example.com", 587, "user", "pass"));

public async Task<T> WithTimeout<T>(Task<T> task, TimeSpan timeout)
{
    var delayTask = Task.Delay(timeout);
    
    var completedTask = await Task.WhenAny(task, delayTask);
    
    if (completedTask == delayTask)
        throw new TimeoutException($"Операция превысила отведенное время {timeout}");
    
    return await task; // Ждем таск еще раз для пробрасывания исключений
}
 
// Использование:
try
{
    var result = await WithTimeout(
        LongRunningOperationAsync(),
        TimeSpan.FromSeconds(5)
    );
}
catch (TimeoutException ex)
{
    // Обработка истечения времени ожидания
}

public async Task<T> WithCancellableTimeout<T>(
    Func<CancellationToken, Task<T>> taskFactory, 
    TimeSpan timeout)
{
    using var cts = new CancellationTokenSource(timeout);
    try
    {
        return await taskFactory(cts.Token);
    }
    catch (OperationCanceledException) when (cts.IsCancellationRequested)
    {
        throw new TimeoutException($"Операция превысила отведенное время {timeout}");
    }
}
 
// Использование:
var result = await WithCancellableTimeout(
    async token => await _repository.GetDataAsync(id, token),
    TimeSpan.FromSeconds(5)
);

public static class TaskExtensions
{
    public static async Task<T> TimeoutAfter<T>(
        this Task<T> task, 
        TimeSpan timeout,
        bool cancelOnTimeout = false)
    {
        using var cts = cancelOnTimeout ? new CancellationTokenSource() : null;
        
        var delayTask = Task.Delay(timeout, cts?.Token ?? CancellationToken.None);
        var resultTask = await Task.WhenAny(task, delayTask);
        
        if (resultTask == delayTask)
        {
            // Если нужно, отменяем исходную задачу
            if (cancelOnTimeout)
                cts.Cancel();
                
            throw new TimeoutException($"Операция превысила отведенное время {timeout}");
        }
        
        // Отменяем задачу задержки, если она еще не завершена
        if (cancelOnTimeout && !delayTask.IsCompleted)
            cts.Cancel();
            
        return await task;
    }
}
 
// Использование:
var result = await _dataService
    .GetLargeFileAsync()
    .TimeoutAfter(TimeSpan.FromMinutes(2), cancelOnTimeout: true);

public async Task ProcessItemsSequentiallyAsync<T>(
    IEnumerable<T> items, 
    Func<T, Task> processAsync)
{
    foreach (var item in items)
    {
        await processAsync(item);
    }
}

public async Task ProcessWithLimitedParallelismAsync<T>(
    IEnumerable<T> items, 
    Func<T, Task> processAsync, 
    int maxParallelism)
{
    using var semaphore = new SemaphoreSlim(maxParallelism);
    var tasks = new List<Task>();
    
    foreach (var item in items)
    {
        await semaphore.WaitAsync();
        
        tasks.Add(Task.Run(async () => 
        {
            try
            {
                await processAsync(item);
            }
            finally
            {
                semaphore.Release();
            }
        }));
    }
    
    await Task.WhenAll(tasks);
}

public async Task<ProcessingResult<T>> ProcessBatchWithControlAsync<T>(
    IEnumerable<T> items,
    Func<T, Task> processAsync,
    int maxParallelism,
    CancellationToken cancellationToken = default)
{
    var result = new ProcessingResult<T>();
    using var semaphore = new SemaphoreSlim(maxParallelism);
    var tasks = new List<Task>();
 
    foreach (var item in items)
    {
        cancellationToken.ThrowIfCancellationRequested();
        await semaphore.WaitAsync(cancellationToken);
        
        tasks.Add(Task.Run(async () => 
        {
            try
            {
                await processAsync(item);
                lock (result)
                    result.Successful.Add(item);
            }
            catch (Exception ex)
            {
                lock (result)
                    result.Failed[item] = ex;
            }
            finally
            {
                semaphore.Release();
            }
        }, cancellationToken));
    }
    
    await Task.WhenAll(tasks);
    return result;
}
 
public class ProcessingResult<T>
{
    public List<T> Successful { get; } = new List<T>();
    public Dictionary<T, Exception> Failed { get; } = new Dictionary<T, Exception>();
    
    public bool HasErrors => Failed.Count > 0;
}

public async Task ProcessInBatchesAsync<T>(
    IEnumerable<T> items,
    Func<T, Task> processAsync,
    int batchSize = 100,
    int maxParallelism = 10,
    IProgress<ProcessingProgress> progress = null,
    CancellationToken cancellationToken = default)
{
    var batches = items.ChunkBy(batchSize);
    var totalItems = items.Count();
    var processedCount = 0;
    
    foreach (var batch in batches)
    {
        var batchTasks = new List<Task>();
        using var semaphore = new SemaphoreSlim(maxParallelism);
        
        foreach (var item in batch)
        {
            await semaphore.WaitAsync(cancellationToken);
            
            batchTasks.Add(Task.Run(async () => 
            {
                try
                {
                    await processAsync(item);
                    
                    var currentProcessed = Interlocked.Increment(ref processedCount);
                    progress?.Report(new ProcessingProgress(
                        currentProcessed, totalItems));
                }
                finally
                {
                    semaphore.Release();
                }
            }, cancellationToken));
        }
        
        await Task.WhenAll(batchTasks);
    }
}
 
public class ProcessingProgress
{
    public ProcessingProgress(int processed, int total)
    {
        ProcessedItems = processed;
        TotalItems = total;
        PercentComplete = (double)processed / total * 100;
    }
    
    public int ProcessedItems { get; }
    public int TotalItems { get; }
    public double PercentComplete { get; }
}

public class DeadlockDemo
{
    // Асинхронный метод
    public async Task<int> GetValueAsync()
    {
        await Task.Delay(1000); // Здесь происходит возврат в контекст синхронизации
        return 42;
    }
    
    // Синхронный метод, вызывающий асинхронный
    public int GetValueSync()
    {
        // Здесь блокируется поток, ожидая завершения задачи
        return GetValueAsync().Result;
    }
}

// Правильно — весь стек вызовов асинхронный
public async Task<int> GetValueAsync()
{
    return await OtherAsyncMethod();
}

public async Task<int> GetValueAsync()
{
    await Task.Delay(1000).ConfigureAwait(false);
    return 42;
}
 
// Теперь можно безопасно блокироваться (хотя этого лучше избегать)
public int GetValueSync()
{
    return GetValueAsync().Result;
}

// Продолжение будет выполнено в оригинальном контексте (UI-поток, контекст ASP.NET и т.д.)
await SomeAsyncMethod();
 
// Продолжение будет выполнено в любом свободном потоке из пула потоков
await SomeAsyncMethod().ConfigureAwait(false);

// В библиотечном коде
public async Task<string> ParseFileAsync(string path)
{
    using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true);
    using var reader = new StreamReader(stream);
    return await reader.ReadToEndAsync().ConfigureAwait(false);
}

// В WPF/Windows Forms/UWP
private async void Button_Click(object sender, EventArgs e)
{
    button.IsEnabled = false;
    try
    {
        var result = await dataService.GetDataAsync(); // Здесь не используем ConfigureAwait(false)
        resultTextBlock.Text = result; // Нужен UI-поток
    }
    finally
    {
        button.IsEnabled = true;
    }
}

async Task ExampleAsync()
{
    await Task.Delay(1000).ConfigureAwait(false); // Отключаем контекст
    await Task.Delay(1000); // Снова захватываем контекст!
    await Task.Delay(1000).ConfigureAwait(false); // Опять отключаем
}

// Плохой код
async void FireAndForgetMethod()
{
    await Task.Delay(1000);
    throw new Exception("Это исключение крашнет приложение!");
}
 
public void DoSomething()
{
    try
    {
        FireAndForgetMethod(); // Вызываем и... забываем
        // Исключение не будет поймано здесь!
    }
    catch (Exception ex)
    {
        // Этот блок не поймает исключения из FireAndForgetMethod
        Console.WriteLine(ex.Message);
    }
}

// Хороший код
async Task FireAndForgetMethodAsync()
{
    await Task.Delay(1000);
    throw new Exception("Это исключение будет поймано!");
}
 
public async Task DoSomethingAsync()
{
    try
    {
        await FireAndForgetMethodAsync(); // Исключение будет поймано
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}

async void Button_Click(object sender, EventArgs e)
{
    try
    {
        await RiskyOperationAsync();
    }
    catch (Exception ex)
    {
        // Логирование или обработка исключения
        Logger.LogError(ex);
        MessageBox.Show(ex.Message);
    }
}

public static class TaskExtensions
{
    public static void FireAndForget(this Task task, Action<Exception> onException = null)
    {
        task.ContinueWith(t => {
            if (t.IsFaulted && onException != null)
            {
                onException(t.Exception.InnerException);
            }
        });
    }
}
 
// Использование
async Task RiskyOperationAsync()
{
    // рискованный код
}
 
// Пожарный вызов с обработкой ошибок
RiskyOperationAsync().FireAndForget(ex => Logger.LogError(ex));

public void StartProcess()
{
    // ПЛОХО: исключения в этой задаче не обрабатываются
    Task.Run(async () => {
        await Task.Delay(100);
        throw new InvalidOperationException("Потерянное исключение");
    });
    
    // Код продолжает работу, не подозревая о проблеме
}

// При возникновении нескольких исключений будет доступно только одно
public async Task ProcessFilesAsync(string[] filePaths)
{
    var tasks = filePaths.Select(path => ProcessFileAsync(path));
    
    await Task.WhenAll(tasks); // Если несколько задач завершились с ошибкой,
                              // получим только первое исключение
}

public async Task StartProcessAsync()
{
    try
    {
        await Task.Run(async () => {
            await Task.Delay(100);
            throw new InvalidOperationException("Это исключение будет поймано");
        });
    }
    catch (Exception ex)
    {
        // Обработка исключения
    }
}

public async Task ProcessFilesAsync(string[] filePaths)
{
    var tasks = filePaths.Select(path => ProcessFileAsync(path)).ToArray();
    
    try
    {
        var whenAllTask = Task.WhenAll(tasks);
        await whenAllTask;
    }
    catch
    {
        // Доступ ко всем исключениям через задачу
        foreach (var task in tasks.Where(t => t.IsFaulted))
        {
            Console.WriteLine(task.Exception.InnerException.Message);
        }
        
        throw; // Пробрасываем дальше, если нужно
    }
}

public async Task ProcessWithTimeoutAsync(string[] urls, TimeSpan timeout)
{
    var tasks = urls.Select(url => FetchDataAsync(url)).ToList();
    
    while (tasks.Count > 0)
    {
        var timeoutTask = Task.Delay(timeout);
        var completedTask = await Task.WhenAny(tasks.Concat(new[] { timeoutTask }));
        
        if (completedTask == timeoutTask)
        {
            // Обработка таймаута
            break;
        }
        
        tasks.Remove(completedTask);
        
        // Проверяем завершенную задачу на наличие ошибок
        if (completedTask.Status == TaskStatus.Faulted)
        {
            // Обработка ошибки
            LogError(completedTask.Exception.InnerException);
        }
        else if (completedTask.Status == TaskStatus.RanToCompletion)
        {
            // Обработка результата
            ProcessResult(await completedTask);
        }
    }
}

// ПЛОХО: блокировка на асинхронной операции
public int GetUserCount()
{
    return GetUserCountAsync().Result; // Потенциальный deadlock
}
 
// Лучше сделать весь стек асинхронным
public async Task<int> GetUserCountAsync()
{
    return await _repository.GetUserCountAsync();
}

// ПЛОХО: нельзя ожидать и отслеживать ошибки
async void SaveData(Data data)
{
    await repository.SaveAsync(data);
}
 
// ХОРОШО: возвращаем Task
async Task SaveDataAsync(Data data)
{
    await repository.SaveAsync(data);
}

// ПЛОХО: начинаем синхронно, затем становимся асинхронными
public string GetFirstUser()
{
    var users = GetUsersAsync().Result; // Блокировка
    return users.FirstOrDefault();
}
 
// ХОРОШО: асинхронный код на всех уровнях
public async Task<string> GetFirstUserAsync()
{
    var users = await GetUsersAsync();
    return users.FirstOrDefault();
}

// ПЛОХО для библиотек: может вызвать deadlock у потребителя
public async Task<int> LibraryMethodAsync()
{
    await Task.Delay(1000); // Используется контекст вызывающего кода
    return 42;
}
 
// ХОРОШО для библиотек
public async Task<int> LibraryMethodAsync()
{
    await Task.Delay(1000).ConfigureAwait(false);
    return 42;
}

// ПЛОХО: исключения теряются
public void ProcessData()
{
    SaveDataAsync(); // Задача игнорируется
    // Продолжаем выполнение до завершения SaveDataAsync
}
 
// ХОРОШО: либо ожидаем задачу
public async Task ProcessDataAsync()
{
    await SaveDataAsync();
}
 
// Или обрабатываем ошибки явно
public void ProcessData()
{
    SaveDataAsync().ContinueWith(t => {
        if (t.IsFaulted)
            LogError(t.Exception);
    });
}

// ПЛОХО: искусственная асинхронность
public async Task<List<Customer>> GetCustomersAsync()
{
    return await Task.Run(() => {
        using var conn = new SqlConnection(_connectionString);
        conn.Open(); // Блокирующий вызов!
        // Синхронный код доступа к БД
        return LoadCustomers(conn);
    });
}
 
// ХОРОШО: настоящая асинхронность
public async Task<List<Customer>> GetCustomersAsync()
{
    using var conn = new SqlConnection(_connectionString);
    await conn.OpenAsync(); // Асинхронный вариант
    // Асинхронное чтение из БД
    return await LoadCustomersAsync(conn);
}

// ПЛОХО: последовательное выполнение, когда параллельного было бы достаточно
public async Task ProcessFilesAsync(string[] filePaths)
{
    foreach (var path in filePaths)
    {
        await ProcessFileAsync(path); // Операции выполняются по очереди
    }
}
 
// ХОРОШО: параллельная обработка с контролем
public async Task ProcessFilesAsync(string[] filePaths)
{
    var tasks = filePaths.Select(path => ProcessFileAsync(path));
    await Task.WhenAll(tasks); // Все операции выполняются параллельно
}

// ПЛОХО: низкоуровневая работа с продолжениями
public Task<int> CalculateValueAsync()
{
    return GetDataAsync().ContinueWith(t => {
        var data = t.Result; // Потенциальный дедлок
        return data * 2;
    });
}
 
// ХОРОШО: простой и понятный код с await
public async Task<int> CalculateValueAsync()
{
    var data = await GetDataAsync();
    return data * 2;
}

// ПЛОХО: async void с ConfigureAwait(false)
async void Button_Click(object sender, RoutedEventArgs e)
{
    await Task.Delay(100).ConfigureAwait(false);
    textBlock.Text = "Готово"; // Ошибка! Неправильный поток
}
 
// ХОРОШО: сохраняем контекст синхронизации
async void Button_Click(object sender, RoutedEventArgs e)
{
    await Task.Delay(100); // Сохраняем контекст UI
    textBlock.Text = "Готово"; // Корректная работа с UI
}

// ПЛОХО: взаимная зависимость
public async Task<User> GetOrCreateUserAsync(string username)
{
    var user = await _userRepository.FindByUsernameAsync(username);
    if (user == null)
    {
        user = new User { Username = username };
        await SaveUserAsync(user);
    }
    return user;
}
 
public async Task SaveUserAsync(User user)
{
    // Проверка на существующего пользователя перед сохранением
    var existingUser = await GetOrCreateUserAsync(user.Username);
    if (existingUser.Id != user.Id)
    {
        throw new DuplicateUserException();
    }
    await _userRepository.SaveAsync(user);
}

public async Task<int> ComputeValueAsync()
{
    Debug.WriteLine($"Поток до await: {Thread.CurrentThread.ManagedThreadId}");
    
    // Если задача завершается мгновенно, поток НЕ переключается
    await Task.FromResult(42);
    
    Debug.WriteLine($"Поток после await: {Thread.CurrentThread.ManagedThreadId}");
    return 42;
}

// ПЛОХО: переменная цикла захватывается в замыкании
public async Task ProcessItemsAsync(string[] items)
{
    var tasks = new List<Task>();
    
    for (int i = 0; i < items.Length; i++)
    {
        tasks.Add(Task.Run(async () => {
            // Здесь i может быть уже увеличена на момент выполнения!
            await ProcessItemAsync(items[i]);
        }));
    }
    
    await Task.WhenAll(tasks);
}
 
// ХОРОШО: создаём локальную копию для каждой итерации
public async Task ProcessItemsAsync(string[] items)
{
    var tasks = new List<Task>();
    
    for (int i = 0; i < items.Length; i++)
    {
        int localIndex = i; // Локальная копия
        tasks.Add(Task.Run(async () => {
            await ProcessItemAsync(items[localIndex]);
        }));
    }
    
    await Task.WhenAll(tasks);
}

// ОПАСНО: значение может измениться во время ожидания
public async Task<string> GetUserDataAsync(User user)
{
    var userData = await _httpClient.GetStringAsync($"api/users/{user.Id}");
    
    // Если во время ожидания user.Id изменился, мы получим данные для старого Id
    return $"Данные пользователя {user.Id}: {userData}";
}
 
// БЕЗОПАСНО: фиксируем значение до асинхронной операции
public async Task<string> GetUserDataAsync(User user)
{
    var userId = user.Id; // Фиксируем значение
    var userData = await _httpClient.GetStringAsync($"api/users/{userId}");
    
    return $"Данные пользователя {userId}: {userData}";
}

// ПЛОХО: потенциальная утечка ресурсов
public async Task<string> ReadFileAsync(string path)
{
    var file = new StreamReader(path);
    var content = await file.ReadToEndAsync();
    file.Dispose(); // Может не выполниться при исключении
    return content;
}
 
// ХОРОШО: используем using для гарантированной очистки
public async Task<string> ReadFileAsync(string path)
{
    using (var file = new StreamReader(path))
    {
        return await file.ReadToEndAsync();
    }
}
 
// Еще лучше с C# 8.0+
public async Task<string> ReadFileAsync(string path)
{
    using var file = new StreamReader(path);
    return await file.ReadToEndAsync();
}

// Менее эффективно, если часто завершается синхронно
public async Task<int> GetCachedValueAsync(string key)
{
    if (_cache.TryGetValue(key, out var value))
        return value; // Всё равно создаётся Task<int>
        
    value = await ComputeValueAsync(key);
    _cache[key] = value;
    return value;
}
 
// Более эффективно при частых кеш-хитах
public async ValueTask<int> GetCachedValueAsync(string key)
{
    if (_cache.TryGetValue(key, out var value))
        return value; // Не создаётся лишний объект Task<int>
        
    value = await ComputeValueAsync(key);
    _cache[key] = value;
    return value;
}

public class ResourceManager
{
    // Фабричный метод вместо асинхронного конструктора
    public static async Task<ResourceManager> CreateAsync()
    {
        var manager = new ResourceManager();
        await manager.InitializeAsync();
        return manager;
    }
    
    private async Task InitializeAsync()
    {
        // Асинхронная инициализация
    }
}

public Task<Result> GetDataAsync() => GetDataAsync(CancellationToken.None);
 
public async Task<Result> GetDataAsync(CancellationToken cancellationToken)
{
    // Реализация с поддержкой отмены
    cancellationToken.ThrowIfCancellationRequested();
    // ...
}

// Вместо async void обертываем в безопасный метод
private void Button_Click(object sender, EventArgs e)
{
    HandleButtonClickAsync().FireAndForget(ex => LogError(ex));
}
 
private async Task HandleButtonClickAsync()
{
    // Асинхронная логика обработки
}

// Вместо обычных Lock объектов
private readonly SemaphoreSlim _lock = new SemaphoreSlim(1, 1);
 
public async Task<Data> GetDataAsync()
{
    await _lock.WaitAsync();
    try
    {
        return await InternalGetDataAsync();
    }
    finally
    {
        _lock.Release();
    }
}

[Test]
public async Task HandleExceptions_ShouldCatchAndLogErrors()
{
    // Устанавливаем мок, возвращающий исключение
    _mockService
        .Setup(s => s.GetDataAsync(It.IsAny<string>()))
        .ThrowsAsync(new InvalidOperationException("Test exception"));
    
    // Проверяем, что наш код корректно обрабатывает исключение
    var result = await _sut.ProcessDataAsync("test");
    
    Assert.That(result.IsSuccess, Is.False);
    Assert.That(result.Error, Contains.Substring("Test exception"));
}

// Синхронный метод, вызывающий асинхронный безопасно
public int GetValue(string key)
{
    // Запускаем асинхронную операцию новым потоком, избегая deadlock
    return Task.Run(() => GetValueAsync(key)).GetAwaiter().GetResult();
}
 
public async Task<int> GetValueAsync(string key)
{
    // Асинхронная реализация
    await Task.Delay(100);
    return 42;
}

public async Task ProcessFilesAsync(string[] files)
{
   foreach (var file in files)
   {
       // Поток возвращается в пул во время ожидания операции ввода-вывода
       var content = await File.ReadAllTextAsync(file);
       // После завершения чтения, поток из пула (возможно другой) 
       // продолжает выполнение кода
       ProcessContent(content);
   }
}

public async Task<PerformanceResult> MeasurePerformanceAsync(Func<Task> asyncMethod, 
                                                        int iterations)
{
    var stopwatch = new Stopwatch();
    var memoryBefore = GC.GetTotalMemory(true);
    
    stopwatch.Start();
    for (int i = 0; i < iterations; i++)
    {
        await asyncMethod();
    }
    stopwatch.Stop();
    
    var memoryAfter = GC.GetTotalMemory(false);
    var memoryUsed = memoryAfter - memoryBefore;
    
    return new PerformanceResult
    {
        TotalTime = stopwatch.Elapsed,
        AverageOperationTime = TimeSpan.FromTicks(stopwatch.Elapsed.Ticks / iterations),
        MemoryUsed = memoryUsed,
        Throughput = iterations / stopwatch.Elapsed.TotalSeconds
    };
}

[MemoryDiagnoser]
public class AsyncBenchmarks
{
    [Benchmark]
    public async Task AsyncImplementation()
    {
        await PerformAsyncOperation();
    }
    
    [Benchmark]
    public void SyncImplementation()
    {
        PerformSyncOperation();
    }
    
    private async Task PerformAsyncOperation()
    {
        // Асинхронная реализация...
    }
    
    private void PerformSyncOperation()
    {
        // Синхронная реализация...
    }
}

// Неоптимально: создаёт новый Task<int> при каждом вызове, даже если результат кэширован
public async Task<int> GetCachedValueAsync(string key)
{
    if (_cache.TryGetValue(key, out var value))
        return value;
    
    value = await FetchValueAsync(key);
    _cache[key] = value;
    return value;
}
 
// Оптимально: использует ValueTask<T> для уменьшения аллокаций
public ValueTask<int> GetCachedValueAsync(string key)
{
    if (_cache.TryGetValue(key, out var value))
        return new ValueTask<int>(value);
    
    return new ValueTask<int>(FetchAndCacheValueAsync(key));
}
 
private async Task<int> FetchAndCacheValueAsync(string key)
{
    var value = await FetchValueAsync(key);
    _cache[key] = value;
    return value;
}

public class BufferedHttpClient
{
    private readonly HttpClient _client;
    private readonly ObjectPool<MemoryStream> _streamPool;
    
    public BufferedHttpClient(HttpClient client)
    {
        _client = client;
        _streamPool = new DefaultObjectPool<MemoryStream>(
            new DefaultPooledObjectPolicy<MemoryStream>());
    }
    
    public async Task<byte[]> GetDataAsync(string url)
    {
        var response = await _client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
        response.EnsureSuccessStatusCode();
        
        var stream = _streamPool.Get();
        try
        {
            await using var contentStream = await response.Content.ReadAsStreamAsync();
            await contentStream.CopyToAsync(stream);
            return stream.ToArray();
        }
        finally
        {
            stream.SetLength(0); // Очищаем перед возвратом в пул
            _streamPool.Return(stream);
        }
    }
}

// Увеличиваем количество одновременных соединений к одному хосту
ServicePointManager.DefaultConnectionLimit = 100;
 
// Предотвращаем повторное использование DNS-записей слишком долго
ServicePointManager.DnsRefreshTimeout = (int)TimeSpan.FromMinutes(1).TotalMilliseconds;
 
// Позволяем повторно использовать порты быстрее после закрытия соединения
ServicePointManager.MaxServicePointIdleTime = (int)TimeSpan.FromSeconds(30).TotalMilliseconds;

public class ThrottledTaskProcessor
{
    private readonly SemaphoreSlim _throttle;
    
    public ThrottledTaskProcessor(int maxConcurrency)
    {
        _throttle = new SemaphoreSlim(maxConcurrency);
    }
    
    public async Task<IEnumerable<TResult>> ProcessBatchAsync<TItem, TResult>(
        IEnumerable<TItem> items,
        Func<TItem, Task<TResult>> processAsync)
    {
        var tasks = new List<Task<TResult>>();
        
        foreach (var item in items)
        {
            await _throttle.WaitAsync();
            
            tasks.Add(Task.Run(async () =>
            {
                try
                {
                    return await processAsync(item);
                }
                finally
                {
                    _throttle.Release();
                }
            }));
        }
        
        return await Task.WhenAll(tasks);
    }
}

public class ComputationService
{
    private readonly TaskFactory _computationTaskFactory;
    
    public ComputationService(int dedicatedThreads)
    {
        var threadPoolSettings = new ThreadPoolSettings
        {
            MinThreads = dedicatedThreads,
            MaxThreads = dedicatedThreads,
            StackSize = 1024 * 1024 // 1 МБ стек
        };
        
        _computationTaskFactory = new TaskFactory(
            new ThreadPoolTaskScheduler(threadPoolSettings));
    }
    
    public Task<ComputationResult> ComputeAsync(ComputationRequest request)
    {
        return _computationTaskFactory.StartNew(() => 
        {
            // Тяжелые вычисления...
            return new ComputationResult();
        });
    }
}

public async Task<OrderResult> ProcessOrderAsync(Order order)
{
    using (var activity = new Activity("ProcessOrder").Start())
    {
        activity.AddTag("OrderId", order.Id);
        activity.AddTag("CustomerId", order.CustomerId);
        
        using (var validateActivity = new Activity("ValidateOrder").Start())
        {
            await ValidateOrderAsync(order);
        }
        
        using (var paymentActivity = new Activity("ProcessPayment").Start())
        {
            await ProcessPaymentAsync(order);
        }
        
        using (var fulfillActivity = new Activity("FulfillOrder").Start())
        {
            await FulfillOrderAsync(order);
        }
        
        return new OrderResult { Success = true };
    }
}

public class AsyncPerformanceMonitor
{
    private readonly ConcurrentDictionary<string, Histogram> _histograms = 
        new ConcurrentDictionary<string, Histogram>();
    
    public async Task<T> TrackOperationAsync<T>(string operationName, Func<Task<T>> operation)
    {
        var histogram = _histograms.GetOrAdd(operationName, _ => new Histogram());
        var stopwatch = Stopwatch.StartNew();
        
        try
        {
            return await operation();
        }
        finally
        {
            stopwatch.Stop();
            histogram.Record(stopwatch.Elapsed.TotalMilliseconds);
        }
    }
    
    public PerformanceMetrics GetMetrics(string operationName)
    {
        if (_histograms.TryGetValue(operationName, out var histogram))
        {
            return new PerformanceMetrics
            {
                OperationName = operationName,
                AverageMs = histogram.Mean,
                MedianMs = histogram.Median,
                P95Ms = histogram.Percentile95,
                P99Ms = histogram.Percentile99,
                MinMs = histogram.Min,
                MaxMs = histogram.Max,
                Count = histogram.Count
            };
        }
        
        return null;
    }
}