C# Academy · Leçon

Modèles CancellationToken et annulation coopérative

Transmettez et respectez CancellationToken : créez un CTS, vérifiez ou déclenchez l’annulation, transmettez le jeton aux API asynchrones et nettoyez les inscriptions.

Modèles CancellationToken et annulation coopérative est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Annulation coopérative

Objectif : annuler le travail de manière coopérative.

Créer un CancellationTokenSource
Transmettre le CancellationToken
Vérifier IsCancellationRequested ou appeler ThrowIfCancellationRequested()
Respecter rapidement et proprement l’annulation

Annulation pilotée par l’appelant

Créez un CancellationTokenSource, transmettez le jeton et annulez depuis l’appelant ; la méthode appelée lève OperationCanceledException.

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

public class Program
{
  static async Task WorkAsync(CancellationToken ct)
  {
    // Poll occasionally; throw to end cooperatively
    for (int i = 0; i < 5; i++)
    {
      ct.ThrowIfCancellationRequested();
      Console.WriteLine("Step " + i);
      await Task.Delay(100, ct); // pass token to async API
    }
  }

  public static void Main(string[] args)
  {
    var cts = new CancellationTokenSource();
    Task t = WorkAsync(cts.Token);

    // Cancel after a short delay (simulated user action)
    Thread.Sleep(180);
    cts.Cancel();

    try
    {
      t.GetAwaiter().GetResult();
    }
    catch (OperationCanceledException)
    {
      Console.WriteLine("Canceled!");
    }
  }
}

Transmission des jetons

Transmettez le jeton à travers chaque couche async afin que les appels internes puissent s’arrêter rapidement.

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

public class Program
{
  static async Task<string> FetchAsync(CancellationToken ct)
  {
    await Task.Delay(80, ct); // pretend I/O
    ct.ThrowIfCancellationRequested();
    return "data";
  }

  static async Task<string> ProcessAsync(CancellationToken ct)
  {
    string raw = await FetchAsync(ct); // forward token
    await Task.Delay(80, ct);
    return raw.ToUpperInvariant();
  }

  public static void Main(string[] args)
  {
    var cts = new CancellationTokenSource();
    Task<string> job = ProcessAsync(cts.Token);
    cts.CancelAfter(100); // schedule a cancellation
    try
    {
      Console.WriteLine(job.GetAwaiter().GetResult());
    }
    catch (OperationCanceledException)
    {
      Console.WriteLine("Pipeline canceled");
    }
  }
}

Nettoyage avec token.Register

Utilisez token.Register pour associer une petite action de nettoyage qui s’exécute lorsqu’une annulation est demandée.

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

public class Program
{
  static async Task UseRegistrationAsync(CancellationToken ct)
  {
    using (ct.Register(() => Console.WriteLine("Cleanup: releasing temp resources")))
    {
      for (int i = 0; i < 3; i++)
      {
        ct.ThrowIfCancellationRequested();
        await Task.Delay(120, ct);
        Console.WriteLine("Tick " + i);
      }
    }
  }

  public static void Main(string[] args)
  {
    var cts = new CancellationTokenSource();
    Task t = UseRegistrationAsync(cts.Token);
    Thread.Sleep(150);
    cts.Cancel();
    try { t.GetAwaiter().GetResult(); }
    catch (OperationCanceledException) { Console.WriteLine("Canceled with cleanup"); }
  }
}

Sources liées

CreateLinkedTokenSource fusionne plusieurs signaux (par exemple, l’annulation par l’utilisateur et le délai d’expiration) en un seul jeton.

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

public class Program
{
  static async Task WorkAsync(CancellationToken ct)
  {
    await Task.Delay(500, ct);
    Console.WriteLine("Finished work");
  }

  public static void Main(string[] args)
  {
    var parent = new CancellationTokenSource();
    var timeout = new CancellationTokenSource();
    timeout.CancelAfter(200);

    // Link both sources: cancel if parent OR timeout requests
    var linked = CancellationTokenSource.CreateLinkedTokenSource(parent.Token, timeout.Token);

    Task t = WorkAsync(linked.Token);
    try { t.GetAwaiter().GetResult(); }
    catch (OperationCanceledException) { Console.WriteLine("Canceled by parent/timeout"); }
    finally { linked.Dispose(); parent.Dispose(); timeout.Dispose(); }
  }
}

Bonnes pratiques

Conseils :

Transmettez les jetons aux API async (Task.Delay, entrées-sorties) afin qu’elles s’arrêtent rapidement.
Levez OperationCanceledException pour terminer le travail ; ne l’ignorez pas.
Appelez Dispose sur le CancellationTokenSource s’il possède des temporisateurs ou des inscriptions.
Gardez les gestionnaires rapides ; effectuez un minimum de travail dans Register.

Règle d’annulation coopérative

Vérification rapide : quelle est la bonne manière pour une méthode de répondre à une demande d’annulation ?

Récapitulatif

Récapitulatif : rendez l’annulation coopérative : transmettez les jetons, vérifiez leur état ou appelez ThrowIfCancellationRequested, associez un petit nettoyage et liez les sources pour combiner les signaux.

Questions Fréquemment Posées

La leçon « Modèles CancellationToken et annulation coopérative » est-elle gratuite ?

Oui — le texte complet de « Modèles CancellationToken et annulation coopérative » 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 « Modèles CancellationToken et annulation coopérative » ?

Transmettez et respectez CancellationToken : créez un CTS, vérifiez ou déclenchez l’annulation, transmettez le jeton aux API asynchrones et nettoyez les inscriptions. 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 1 sur 3.

Combien de temps prend la leçon « Modèles CancellationToken et annulation coopérative » ?

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