C# async

  public static async Task run1()
  {
      Console.WriteLine("Début");
      await AttenteAsync();
      Console.WriteLine("Fin");
  }
  public static async Task AttenteAsync()
  {
      await Task.Delay(2000); // Attend 2 secondes de manière asynchrone
      Console.WriteLine("Attente terminée");
  }

 public static async Task run2()
 {
     var ret = CalculerAsync(5);
     var resultat = await CalculerAsync(5);
     Console.WriteLine($"Résultat : {resultat}");
 }

 static async Task CalculerAsync(int x)
 {
     await Task.Delay(10000); // simulation calcul long
     return x * x;
 }

public static async Task run3()
{
    var t1 = OperationAsync("A", 20000);
    var t2 = OperationAsync("B", 10000);

    await Task.WhenAll(t1, t2); // attend que toutes les tâches soient terminées
    Console.WriteLine("Toutes les opérations terminées !");
    return "ok tout est terminé";
}

static async Task OperationAsync(string nom, int delai)
{
    Console.WriteLine($"Opération {nom} démarrée");
    await Task.Delay(delai);
    Console.WriteLine($"Opération {nom} terminée");
}

 public async Task<int> CalculerAsync(int n)
 {
     for (int i = 0; i < n; i++)
         await Task.Delay(1000); // simulation d'opération longue
     Console.WriteLine($"task end {n}");
     return n*10;
 }

 public async Task ExempleParallel()
 {
     var tasks = new List<Task<int>>();
     for (int i = 0; i < 10; i++)
     {
         tasks.Add(CalculerAsync(i%5+1));
     }
     int[] results = await Task.WhenAll(tasks);
     foreach (int result in results)
     {
         Console.WriteLine($"Result: {result}");
     }
     Console.WriteLine("Toutes les tâches terminées");
 }

 public async Task Run()
 {
     await ExempleParallel();
 }

 
    

public async Task<int> CalculerAsync(int n)
{
    for (int i = 0; i < n; i++)
        await Task.Delay(1000); // simulation d'opération longue
    Console.WriteLine($"task end {n}");
    return n * 10;
}

public async Task<T> WithTimeout<T>(Task<T> task, int timeoutMs)
{
    var timeout = Task.Delay(timeoutMs);
    var finish = await Task.WhenAny(task, timeout);

    if (finish == timeout)
    {
        Console.WriteLine("Timed out");
    }

    return await task; // retourne le résultat original
}

public async Task  Run()
{
    Task<int> t = CalculerAsync(1);
    int value = await WithTimeout(t, 500);
}

public async Task<int> CalculerAsync(int n, CancellationToken token)
{
    for (int i = 0; i < n; i++)
    {
        token.ThrowIfCancellationRequested(); // vérifie l'annulation
        await Task.Delay(1000); // simulation d'opération longue
    }
    Console.WriteLine($"task end {n}");
    return n * 10;
}

public async Task<T> AvecTimeout<T>(Func<CancellationToken, Task<T>> action, int timeoutMs)
{
    using var cts = new CancellationTokenSource();

    var task = action(cts.Token);              // task qui supporte l'annulation
    var timeout = Task.Delay(timeoutMs, cts.Token);

    var finished = await Task.WhenAny(task, timeout);

    if (finished == timeout)
    {
        cts.Cancel();                          // demande d'annulation
        Console.WriteLine("C A N C E L");
    }

    return await task;
}


public async Task Run()
{
    try
    {
        var result = await AvecTimeout(async token =>
        {
            return await CalculerAsync(10, token);      // méthode annulable
        }, 20000);
        Console.WriteLine($"Resultat {result}");
    }
    catch (TimeoutException)
    {
        Console.WriteLine("TimeoutException");
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine("OperationCanceledException");
    }
}

 
 public void RunInBackground()
 {
     Task.Run(() =>
     {
         for (int i = 0; i < 10; i++)
         {
             Thread.Sleep(1000);
             Console.WriteLine("Tâche en background");
         }
     });
 }

 var p = new MainTuto();
p.RunInBackground();

for (int i = 0; i < 100; i++)
{
    Console.WriteLine($"Main {i}");
    Task.Delay(100).Wait(); // bloque
}

 public void RunInBackground()
 {
     // If already running, ignore or stop first
     if (_backgroundTask is { IsCompleted: false }) return;

     _cts = new CancellationTokenSource();
     var token = _cts.Token;

     // Start the background task
     _backgroundTask = Task.Run(async () =>
     {
         try
         {
             for (int i = 0; i < 10; i++)
             {
                 // Non-blocking delay that supports cancellation
                 await Task.Delay(1000, token);
                 Console.WriteLine("Tâche en background");
             }
         }
         catch (OperationCanceledException)
         {
             Console.WriteLine("Background task: cancelled.");
             throw;
         }
         catch (Exception ex)
         {
             Console.WriteLine($"Background task error: {ex}");
         }
     }, token);
 }

 public async Task StopAsync()
 {
     if (_cts is null) return;

     try
     {
         _cts.Cancel();                 
         if (_backgroundTask != null)
             await _backgroundTask;     
     }
     catch (OperationCanceledException)
     {
         Console.WriteLine("C A N C E L");
     }
     finally
     {
         _cts.Dispose();
         _cts = null;
         _backgroundTask = null;
         Console.WriteLine("C A N C E L");
     }
 }