C# Academy · Leçon

Délais d’expiration, IProgress<T> et ressources asynchrones (émulation)

Délais d’expiration, IProgress<T> et ressources asynchrones (émulation) est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.

Plan

Objectif :

Gérer un délai d’expiration avec CancelAfter
Gérer un délai d’expiration avec Task.WhenAny
Signaler la progression avec IProgress<T>
Utiliser le modèle de nettoyage async en C# 6 (try/finally)

Délai d’expiration avec CancelAfter

Utilisez CancelAfter et transmettez le jeton à l’API async ; la méthode appelée s’arrête de manière coopérative à l’expiration du délai.

using System;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
  static async Task<string> SlowOpAsync(CancellationToken ct)
  {
    // Simulate slow I/O that honors cancellation
    await Task.Delay(500, ct);
    return "OK";
  }

  public static void Main(string[] args)
  {
    var cts = new CancellationTokenSource();
    cts.CancelAfter(150); // timeout after 150 ms

    Task<string> t = SlowOpAsync(cts.Token);
    try
    {
      string result = t.GetAwaiter().GetResult(); // demo only
      Console.WriteLine(result);
    }
    catch (OperationCanceledException)
    {
      Console.WriteLine("Timed out");
    }
  }
}

Délai d’expiration avec WhenAny

Task.WhenAny met le travail en concurrence avec Task.Delay ; si le délai l’emporte, levez une TimeoutException.

using System;
using System.Threading.Tasks;

public class Program
{
  // Wrap any Task<T> with a timeout using WhenAny
  static async Task<T> WithTimeoutAsync<T>(Task<T> work, int milliseconds)
  {
    Task delay = Task.Delay(milliseconds);
    Task first = await Task.WhenAny(work, delay);
    if (first == work) return await work; // completed in time
    throw new TimeoutException("Operation timed out");
  }

  static async Task<int> ComputeAsync()
  {
    await Task.Delay(300); // pretend work
    return 7;
  }

  public static void Main(string[] args)
  {
    try
    {
      int v = WithTimeoutAsync(ComputeAsync(), 100).GetAwaiter().GetResult();
      Console.WriteLine("Value " + v);
    }
    catch (TimeoutException ex)
    {
      Console.WriteLine(ex.Message);
    }
  }
}

Démonstration de IProgress<T>

IProgress<T> découple le travail de l’interface utilisateur ; les producteurs appellent Report, tandis que les consommateurs mettent à jour l’interface ou le thread de manière sûre.

using System;
using System.Threading.Tasks;

public class Program
{
  static async Task DownloadAsync(IProgress<int> progress)
  {
    // Report 0..100 in steps; UI would receive ProgressChanged on its context
    for (int p = 0; p <= 100; p += 25)
    {
      await Task.Delay(60);
      if (progress != null) progress.Report(p);
    }
  }

  public static void Main(string[] args)
  {
    Progress<int> prog = new Progress<int>(percent =>
    {
      Console.WriteLine("Progress: " + percent + "%");
    });

    DownloadAsync(prog).GetAwaiter().GetResult();
  }
}

Modèle de nettoyage async

C# 6 ne dispose pas de IAsyncDisposable ; utilisez try/finally et effectuez la libération dans finally après la fin du travail attendu.

using System;
using System.IO;
using System.Threading.Tasks;

public class Program
{
  static async Task WriteThenCloseAsync(string path)
  {
    // C# 6 has no IAsyncDisposable; emulate with try/finally.
    FileStream fs = null;
    StreamWriter sw = null;
    try
    {
      fs = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
      sw = new StreamWriter(fs);
      await sw.WriteAsync("hello"); // do async work
      await sw.FlushAsync();        // ensure data is flushed
    }
    finally
    {
      // Dispose synchronously in finally
      if (sw != null) sw.Dispose();
      else if (fs != null) fs.Dispose();
    }
  }

  public static void Main(string[] args)
  {
    WriteThenCloseAsync("out.txt").GetAwaiter().GetResult();
    Console.WriteLine("Written");
  }
}

Bonnes pratiques

Conseils :

Préférez CancelAfter pour les délais d’expiration simples des opérations.
Utilisez WhenAny pour les flux de délai d’expiration personnalisés.
Gardez les types de progression simples, par exemple un entier représentant un pourcentage ou une structure simple.
Terminez toujours les opérations await avant de libérer les ressources ; placez la libération dans finally.

Modèle de délai d’expiration

Vérification rapide : quelle est une manière simple d’ajouter un délai d’expiration à une opération async en C# 6 sans bloquer ?

Récapitulatif

Récapitulatif : implémentez les délais d’expiration avec CancelAfter ou WhenAny, signalez la progression avec IProgress<T> et simulez la libération asynchrone des ressources avec try/finally en C# 6.

Questions Fréquemment Posées

La leçon « Délais d’expiration, IProgress<T> et ressources asynchrones (émulation) » est-elle gratuite ?

Oui — le texte complet de « Délais d’expiration, IProgress<T> et ressources asynchrones (émulation) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Délais d’expiration, IProgress<T> et ressources asynchrones (émulation) » ?

Appliquez des délais d’expiration avec CancelAfter ou avec Task.WhenAny, connectez IProgress pour des mises à jour adaptées aux interfaces utilisateur et utilisez try/finally pour émuler le nettoyage… Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.

Combien de temps prend la leçon « Délais d’expiration, IProgress<T> et ressources asynchrones (émulation) » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Modèles CancellationToken et annulation coopérative
Délais d’expiration, IProgress et ressources asynchrones (émulation)
Principes de résilience : nouvelles tentatives et temporisation progressive

← Retour à C# Academy