.net Task Cancellationtoken Example

INFLUENCESMAG.ORG

4 min read

·

Jun 04, 2024

35

Share

Annuler des tâches dans .NET avec CancellationToken

Dans le monde du développement .NET, la gestion des tâches asynchrones est cruciale pour optimiser les performances et la réactivité des applications. L'une des fonctionnalités essentielles pour un contrôle précis des tâches est l'utilisation de CancellationToken. Cet outil puissant permet d'annuler proprement des tâches en cours d'exécution, évitant ainsi les blocages et les ressources inutilement utilisées.

Introduction à CancellationToken

CancellationToken est un objet .NET qui sert à signaler l'annulation d'une tâche. Il agit comme un mécanisme de communication entre le code qui lance la tâche et celui qui l'exécute. Lorsque le code qui lance la tâche veut l'annuler, il envoie un signal via le CancellationToken. Le code exécutant la tâche surveille régulièrement le CancellationToken pour détecter ce signal et interrompre son exécution.

Utilisation de CancellationToken

Voici un exemple simple d'utilisation de CancellationToken pour annuler une tâche asynchrone:

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

public class CancellationExample
{
    public static async Task Main(string[] args)
    {
        // Créer un CancellationTokenSource
        var cts = new CancellationTokenSource();
        var token = cts.Token;

        // Démarrer une tâche asynchrone
        Task task = Task.Run(() =>
        {
            // Exécuter une tâche longue durée
            Console.WriteLine("Début de la tâche");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine($"Étape {i + 1}");
                Thread.Sleep(1000);
                // Vérifier si l'annulation a été demandée
                if (token.IsCancellationRequested)
                {
                    Console.WriteLine("Annulation demandée !");
                    return;
                }
            }
            Console.WriteLine("Fin de la tâche");
        }, token);

        // Attendre un certain temps avant d'annuler la tâche
        Console.WriteLine("Attente de 5 secondes avant l'annulation");
        await Task.Delay(5000);

        // Annuler la tâche
        cts.Cancel();

        // Attendre la fin de la tâche (même si elle a été annulée)
        await task;

        Console.WriteLine("Fin du programme");
    }
}

Dans cet exemple, la tâche exécute une boucle de 10 itérations, chaque itération simulant une opération longue durée. À chaque itération, la tâche vérifie si le CancellationToken a été annulé. Si c'est le cas, la tâche est immédiatement interrompue. Après 5 secondes, le code principal annule la tâche via cts.Cancel().

Points clés à retenir

• CancellationToken permet un contrôle précis de l'annulation des tâches asynchrones.
• Il est important de vérifier régulièrement le statut du CancellationToken pour détecter une demande d'annulation.
• L'utilisation de CancellationToken améliore la robustesse et la réactivité des applications .NET.

En conclusion, CancellationToken est un outil indispensable pour la gestion des tâches asynchrones dans .NET. Il facilite l'annulation propre des tâches, garantissant un fonctionnement fluide et optimisé des applications.