День 1724. #ЗаметкиНаПолях
Структурированный Параллелизм в C#
Структурированный параллелизм — это концепция, которая помогает писать более надёжный и удобный в обслуживании асинхронный код. Она не нова, но не так широко известна. Идея состоит в том, чтобы иметь возможность группировать асинхронные операции и гарантировать, что все операции завершатся до завершения группы. Это делается с помощью специальной конструкции, называемой областью задачи (Task Scope). Область задачи — это конструкция, похожая на блок try-catch-finally. Она используется для группировки асинхронных операций и обеспечения завершения всех операций до завершения группы.
Рассмотрим пример:

public class TaskScope
{
  private CancellationTokenSource _cts = new();
  private ConcurrentBag<Task> _tasks = new();

  private TaskScope() { }

  public static async Task Create(
   Func<TaskScope, Task> act)
  {
    await using var ts = new TaskScope();
    await act(ts);
    await ts.WaitForAll();
  }
    
  public static async Task Create(
   Action<TaskScope> act)
  {
    await using var ts = new TaskScope();
    act(ts);
    await ts.WaitForAll();
  }

  public async ValueTask DisposeAsync()
  {
    _cts.Cancel();
    await WaitForAll();
  }

  public Task Run(
   Func<CancellationToken, Task> act)
  {
    var task = Task.Run(async () =>
    {
      try
      {
        await act(_cts.Token);
      }
      catch (Exception ex) when (
       ex is not OperationCanceledException)
      {
        _cts.Cancel();
         throw;
       }
     });

     _tasks.Add(task);
     return task;
  }

  private async Task WaitForAll()
  {
    try
    {
      await Task.WhenAll(_tasks.ToArray());
    }
    catch (Exception ex) when (
     ex is not OperationCanceledException)
    {
      throw;
    }
  }
}

Извините за много кода, но это только упрощённая реализация.
Идея в том, что мы определяем области в методе Create. Всё внутри Create будет выполняться в определённой области. Таким образом, задачи логически связаны друг с другом: если в одной выбрасывается исключение, мы отменяем все задачи вместе.
Использование:

var tasks = TaskScope.Create(group =>
{
  group.Run(async token =>
  {
    await Task.Delay(100, token);
    throw new Exception("Boom!!!");
  });
  group.Run(async token => 
   await Task.Delay(1000, token));
});

// Выполняется 100мс
// после ошибки в 1й задаче отменяются все.
// Исключение поднимается наверх
try
{
  await tasks;
}
catch (Exception ex)
{
  Console.WriteLine(ex.Message);
}

// True
Console.WriteLine(tasks.IsFaulted);

Как видите, мы можем сгруппировать задачи и убедиться, что все они выполнены до того, как будет завершена область действия. Если одна из задач завершается сбоем, все остальные задачи отменяются и появляется исключение. Это очень мощная концепция, которая помогает писать более надёжный и удобный в обслуживании асинхронный код. Более сложную реализацию можно найти здесь.

Источник: https://steven-giesel.com/blogPost/59e57336-7c73-472f-a781-b0b79f0d47ad