.net Task.run Cancellationtoken

INFLUENCESMAG.ORG

5 min read

·

Jun 04, 2024

31

Share

Annuler des tâches asynchrones avec Task.Run et CancellationToken

Le framework .NET fournit un mécanisme puissant pour gérer les tâches asynchrones, notamment à travers la classe Task.Run et l'utilisation des CancellationToken. Ces outils sont essentiels pour une gestion efficace des tâches longues et pour la possibilité de les interrompre à la demande.

Comprendre les CancellationToken

Un CancellationToken est un objet qui représente un signal d'annulation. Il permet à un code de vérifier si une opération doit être interrompue. Lorsqu'un CancellationToken est annulé, tous les objets qui lui sont associés reçoivent un signal d'arrêt.

Utiliser Task.Run avec CancellationToken

La méthode Task.Run est idéale pour exécuter des tâches longues dans un thread distinct. Elle permet d'éviter de bloquer le thread principal et d'améliorer la réactivité de l'application. En intégrant un CancellationToken à l'appel de Task.Run, vous pouvez contrôler l'exécution de la tâche et la terminer si nécessaire.

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

// Créer un CancellationTokenSource
CancellationTokenSource cts = new CancellationTokenSource();

// Créer une tâche avec Task.Run et un CancellationToken
Task task = Task.Run(() => {
    // Vérifier l'état du CancellationToken à intervalles réguliers
    while (!cts.Token.IsCancellationRequested) 
    {
        // Exécuter le code de la tâche
        // ...

        // Simuler un délai
        Thread.Sleep(1000); 
    }
}, cts.Token);

// Attendre la fin de la tâche, avec un timeout éventuel
try
{
    // Annuler la tâche après 5 secondes
    await Task.WhenAny(task, Task.Delay(5000));

    // Si la tâche n'est pas terminée, l'annuler
    if (!task.IsCompleted)
    {
        cts.Cancel(); 
        // Gérer l'annulation éventuelle 
        // ...
    }

    // Attendre la fin de la tâche
    await task;
}
catch (OperationCanceledException) 
{
    // Gérer l'exception d'annulation
    // ...
}

Explication du code :

1. Création d'un CancellationTokenSource: Un CancellationTokenSource est nécessaire pour créer un CancellationToken et gérer son annulation.
2. Démarrage de la tâche avec Task.Run: La méthode Task.Run exécute le code de la tâche dans un thread séparé. Le CancellationToken est passé en paramètre.
3. Vérification de l'état du CancellationToken: Le code de la tâche vérifie l'état du CancellationToken à l'aide de la propriété IsCancellationRequested. Si la propriété est true, la tâche est annulée.
4. Annulation de la tâche: Le code principal appelle la méthode Cancel() du CancellationTokenSource. Cela annule le CancellationToken associé et interrompt la tâche.
5. Gestion des exceptions: En cas d'annulation, une exception OperationCanceledException est levée. Vous devez gérer cette exception pour gérer l'annulation de manière appropriée.

Avantages de l'utilisation de CancellationToken

• Contrôle de la durée d'exécution: Vous pouvez annuler des tâches longues si elles ne sont plus nécessaires.
• Réactivité de l'application: L'application reste réactive même si des tâches longues sont en cours d'exécution.
• Gestion des ressources: L'annulation permet de libérer les ressources utilisées par les tâches qui ne sont plus nécessaires.

En conclusion, l'utilisation de Task.Run et CancellationToken est essentielle pour une gestion efficace des tâches asynchrones dans .NET. Ils permettent de contrôler l'exécution des tâches, d'interrompre les opérations inutiles et d'améliorer la réactivité et la fiabilité des applications.