C# Cancellationtoken (Comment ça fonctionne pour les développeurs)

Comment ça fonctionne ?

En essence, un CancellationToken est passé à une tâche ou méthode, qui vérifie périodiquement si une annulation a été demandée. Si c'est le cas, la tâche peut se terminer en douceur, libérant des ressources et améliorant la réactivité de votre application. C'est particulièrement utile dans des cas comme la génération de PDF, où des documents complexes peuvent prendre du temps à être créés.

En utilisant des CancellationTokens, vous évitez les inconvénients potentiels des tâches qui s'exécutent inutilement longtemps, tels que les ressources systèmes gaspillées et une mauvaise expérience utilisateur.

Tokens d'annulation internes

En C#, un token d'annulation interne fait référence à un token d'annulation qui est créé et géré au sein d'une classe ou méthode spécifique, plutôt que passé depuis une source externe. Cela permet un contrôle plus fin de l'annulation des tâches dans le cadre d'un composant unique, lui permettant de surveiller et de répondre aux demandes d'annulation qui proviennent de l'intérieur.

Utiliser un token d'annulation interne est particulièrement utile dans des scénarios où vous souhaitez encapsuler la logique d'annulation sans l'exposer aux consommateurs de votre classe, maintenant ainsi une interface propre. Cette approche peut améliorer la modularité du code et rendre plus facile la gestion de workflows asynchrones complexes tout en profitant de la flexibilité fournie par le cadre plus large du CancellationToken.

1. Prévenir une charge inutile

Si un utilisateur n'a plus besoin du PDF qu'il a demandé, il n'y a aucune raison pour que le processus continue. En utilisant CancellationToken, vous pouvez interrompre la tâche de génération de PDF, évitant ainsi une charge excessive sur vos serveurs et améliorant les performances générales de l'application.

2. Améliorer l'expérience utilisateur

Dans les applications de bureau, la génération de PDF pourrait se produire sur le fil d'interface utilisateur, ce qui pourrait bloquer l'interface utilisateur si la tâche est de longue durée. En intégrant CancellationToken, les utilisateurs peuvent annuler la tâche et garder l'application réactive.

3. Améliorer l'évolutivité

Dans les applications web où de nombreux utilisateurs génèrent des PDFs simultanément, l'évolutivité est essentielle. CancellationToken vous permet d'annuler en toute sécurité des tâches inutiles, libérant des ressources pour gérer efficacement d'autres demandes.

Étape 1 : configurer IronPDF dans votre projet

Pour commencer à utiliser IronPDF, vous devrez d'abord l'installer. S'il est déjà installé, vous pouvez passer à la section suivante ; sinon, les étapes suivantes couvrent comment installer la bibliothèque IronPDF.

Via la console du gestionnaire de packages NuGet

Pour installer IronPDF en utilisant la console du gestionnaire de packages NuGet, ouvrez Visual Studio et accédez à la console du gestionnaire de packages. Ensuite, exécutez la commande suivante :

Install-Package IronPdf

Via le Package Manager NuGet pour la solution

En ouvrant Visual Studio, allez dans "Outils -> Package Manager NuGet -> Gérer les packages NuGet pour la solution" et recherchez IronPDF. À partir de là, il vous suffit de sélectionner votre projet et de cliquer sur "Installer", et IronPDF sera ajouté à votre projet.

Une fois que vous avez installé IronPDF, tout ce dont vous avez besoin pour commencer à utiliser IronPDF est de la déclaration using correcte en haut de votre code :

using IronPdf;

using IronPdf;

Imports IronPdf

Étape 2 : utiliser des tokens d'annulation dans une méthode asynchrone de génération de PDF

Plongeons dans l'implémentation réelle. Dans cet exemple, nous générerons un PDF simple à partir de HTML en utilisant IronPDF, mais avec un CancellationToken qui permet d'annuler la tâche si nécessaire.

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

public class PdfGenerator
{
    public async Task GeneratePdfWithCancellation(CancellationToken token)
    {
        var Renderer = new ChromePdfRenderer();
        try
        {
            // Check for cancellation before starting
            token.ThrowIfCancellationRequested();

            // Simulating a long task that can be checked for cancellation periodically
            for (int i = 0; i < 10; i++)
            {
                // Simulating a piece of work (this could be part of a larger HTML rendering)
                await Task.Delay(500); // Simulate chunk processing

                // Periodically check for cancellation in long-running operations
                if (token.IsCancellationRequested)
                {
                    Console.WriteLine("Cancellation requested. Throwing exception.");
                    token.ThrowIfCancellationRequested();  // This will trigger an OperationCanceledException
                }
            }

            // Simulate PDF creation after the long process
            var pdf = await Renderer.RenderHtmlAsPdfAsync("<h1>Hello, PDF!</h1>");

            // Save the PDF after ensuring no cancellation occurred
            pdf.SaveAs("output.pdf");
            Console.WriteLine("PDF generated successfully.");
        }
        catch (OperationCanceledException)
        {
            // Handle task cancellation
            Console.WriteLine("PDF generation was canceled.");
        }
        catch (Exception ex)
        {
            // Handle other exceptions
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

public class Program
{
    public static async Task Main(string[] args)
    {
        // Create a CancellationTokenSource
        var cancellationTokenSource = new CancellationTokenSource();

        // Create our cancellation token
        var token = cancellationTokenSource.Token;

        // Start the PDF generation task
        var pdfGenerator = new PdfGenerator();
        Task pdfTask = pdfGenerator.GeneratePdfWithCancellation(token);

        // Simulate a cancellation scenario
        Console.WriteLine("Press any key to cancel PDF generation...");
        Console.ReadKey();

        // Cancel the task by calling Cancel() on the CancellationTokenSource
        cancellationTokenSource.Cancel();

        try
        {
            // Await the task to handle any exceptions, such as cancellation
            await pdfTask;
        }
        catch (OperationCanceledException)
        {
            // Confirm the cancellation
            Console.WriteLine("The PDF generation was canceled.");
        }
        finally
        {
            cancellationTokenSource.Dispose();
        }

        Console.WriteLine("Program finished.");
    }
}

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

public class PdfGenerator
{
    public async Task GeneratePdfWithCancellation(CancellationToken token)
    {
        var Renderer = new ChromePdfRenderer();
        try
        {
            // Check for cancellation before starting
            token.ThrowIfCancellationRequested();

            // Simulating a long task that can be checked for cancellation periodically
            for (int i = 0; i < 10; i++)
            {
                // Simulating a piece of work (this could be part of a larger HTML rendering)
                await Task.Delay(500); // Simulate chunk processing

                // Periodically check for cancellation in long-running operations
                if (token.IsCancellationRequested)
                {
                    Console.WriteLine("Cancellation requested. Throwing exception.");
                    token.ThrowIfCancellationRequested();  // This will trigger an OperationCanceledException
                }
            }

            // Simulate PDF creation after the long process
            var pdf = await Renderer.RenderHtmlAsPdfAsync("<h1>Hello, PDF!</h1>");

            // Save the PDF after ensuring no cancellation occurred
            pdf.SaveAs("output.pdf");
            Console.WriteLine("PDF generated successfully.");
        }
        catch (OperationCanceledException)
        {
            // Handle task cancellation
            Console.WriteLine("PDF generation was canceled.");
        }
        catch (Exception ex)
        {
            // Handle other exceptions
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

public class Program
{
    public static async Task Main(string[] args)
    {
        // Create a CancellationTokenSource
        var cancellationTokenSource = new CancellationTokenSource();

        // Create our cancellation token
        var token = cancellationTokenSource.Token;

        // Start the PDF generation task
        var pdfGenerator = new PdfGenerator();
        Task pdfTask = pdfGenerator.GeneratePdfWithCancellation(token);

        // Simulate a cancellation scenario
        Console.WriteLine("Press any key to cancel PDF generation...");
        Console.ReadKey();

        // Cancel the task by calling Cancel() on the CancellationTokenSource
        cancellationTokenSource.Cancel();

        try
        {
            // Await the task to handle any exceptions, such as cancellation
            await pdfTask;
        }
        catch (OperationCanceledException)
        {
            // Confirm the cancellation
            Console.WriteLine("The PDF generation was canceled.");
        }
        finally
        {
            cancellationTokenSource.Dispose();
        }

        Console.WriteLine("Program finished.");
    }
}

Imports IronPdf
Imports System
Imports System.Threading
Imports System.Threading.Tasks

Public Class PdfGenerator
	Public Async Function GeneratePdfWithCancellation(ByVal token As CancellationToken) As Task
		Dim Renderer = New ChromePdfRenderer()
		Try
			' Check for cancellation before starting
			token.ThrowIfCancellationRequested()

			' Simulating a long task that can be checked for cancellation periodically
			For i As Integer = 0 To 9
				' Simulating a piece of work (this could be part of a larger HTML rendering)
				Await Task.Delay(500) ' Simulate chunk processing

				' Periodically check for cancellation in long-running operations
				If token.IsCancellationRequested Then
					Console.WriteLine("Cancellation requested. Throwing exception.")
					token.ThrowIfCancellationRequested() ' This will trigger an OperationCanceledException
				End If
			Next i

			' Simulate PDF creation after the long process
			Dim pdf = Await Renderer.RenderHtmlAsPdfAsync("<h1>Hello, PDF!</h1>")

			' Save the PDF after ensuring no cancellation occurred
			pdf.SaveAs("output.pdf")
			Console.WriteLine("PDF generated successfully.")
		Catch e1 As OperationCanceledException
			' Handle task cancellation
			Console.WriteLine("PDF generation was canceled.")
		Catch ex As Exception
			' Handle other exceptions
			Console.WriteLine($"An error occurred: {ex.Message}")
		End Try
	End Function
End Class

Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Create a CancellationTokenSource
		Dim cancellationTokenSource As New CancellationTokenSource()

		' Create our cancellation token
		Dim token = cancellationTokenSource.Token

		' Start the PDF generation task
		Dim pdfGenerator As New PdfGenerator()
		Dim pdfTask As Task = pdfGenerator.GeneratePdfWithCancellation(token)

		' Simulate a cancellation scenario
		Console.WriteLine("Press any key to cancel PDF generation...")
		Console.ReadKey()

		' Cancel the task by calling Cancel() on the CancellationTokenSource
		cancellationTokenSource.Cancel()

		Try
			' Await the task to handle any exceptions, such as cancellation
			Await pdfTask
		Catch e1 As OperationCanceledException
			' Confirm the cancellation
			Console.WriteLine("The PDF generation was canceled.")
		Finally
			cancellationTokenSource.Dispose()
		End Try

		Console.WriteLine("Program finished.")
	End Function
End Class

Sortie console

Sortie PDF

Dans cet exemple, nous démontrons comment utiliser un CancellationToken dans un programme C# pour annuler une tâche de génération de PDF de longue durée avec IronPDF. Le code est structuré en deux parties : le processus de génération de PDF (classe PdfGenerator) et la logique principale du programme (classe Program).

• Classe PdfGenerator: Cette classe contient une méthode qui simule la génération d'un fichier PDF tout en prenant en charge l'annulation via un CancellationToken.
• Nous créons notre source de tokens d'annulation dans la méthode main en utilisant CancellationTokenSource(), puis créons notre objet token en passant la propriété du Token du CancellationTokenSource à celle-ci.
• ChromePdfRenderer est utilisé à partir de la bibliothèque IronPDF pour rendre le contenu HTML dans un document PDF.
• La méthode GeneratePdfWithCancellation est asynchrone (async) et renvoie une tâche. Cette méthode accepte un CancellationToken (token) pour gérer l'annulation de la tâche via la demande d'annulation.
• Le CancellationToken nous permet d'annuler en toute sécurité les opérations de longue durée. Cependant, l'annulation est coopérative, ce qui signifie que la tâche elle-même doit vérifier périodiquement l'état du token.
• Dans ce code, nous simulons une longue tâche avec des vérifications d'annulation périodiques. Le point clé est que nous vérifions manuellement l'annulation (token.IsCancellationRequested) pendant le processus de génération du PDF, prêts à exécuter la méthode d'annulation si le jeton lui est transmis.
• Si l'utilisateur appuie sur une touche pour signaler l'annulation du programme, la tâche s'arrête en douceur et lance une OperationCanceledException, empêchant la réalisation de la génération du PDF de manière appropriée et en temps opportun.
• Le PDF résultant est enregistré sous "output.pdf" si aucune annulation ne s'est produite pour éviter que le programme n'exécute le processus de tâche complète.

1. Applications Web

Dans une application web, les utilisateurs initient souvent des actions telles que la génération de rapports au format PDF. Cependant, si l'utilisateur quitte la page ou ferme le navigateur, le système peut détecter cela et utiliser CancellationToken pour arrêter le processus de génération de PDF.

HttpContext.Response.RegisterForDispose(CancellationTokenSource);

HttpContext.Response.RegisterForDispose(CancellationTokenSource);

HttpContext.Response.RegisterForDispose(CancellationTokenSource)

Cette implémentation simple permet aux serveurs web de s'adapter plus efficacement en ne dédiant pas de ressources à des tâches qui ne sont plus nécessaires.

2. Rapports de longue durée

Dans les applications de reporting, les utilisateurs peuvent demander à exporter de grands ensembles de données sous forme de PDFs. Si l'utilisateur change d'avis ou fait une requête incorrecte, CancellationToken vous permet d'annuler la tâche à mi-parcours, évitant ainsi le gaspillage de ressources.

3. Services en arrière-plan

Dans les services en arrière-plan ou les microservices, les tâches qui prennent un temps considérable, comme générer de gros lots de PDF, peuvent être gérées plus efficacement en utilisant CancellationToken. Lorsque le service est sur le point de s'arrêter ou d'être réduit, les tâches en cours peuvent être annulées proprement, garantissant qu'aucune donnée n'est perdue ou corrompue.