C# CancellationToken (Comment Ça Fonctionne Pour Les Développeurs)

Dans le développement logiciel moderne, gérer efficacement les tâches de longue durée est crucial, surtout dans les applications où la génération de fichiers PDF volumineux ou complexes est courante. Les développeurs C# comptent souvent sur IronPDF pour une création de PDF sans faille, mais la gestion des tâches de génération de PDF potentiellement longues nécessite un moyen de gérer les interruptions ou annulations par les utilisateurs.

C'est ici que leCancellationTokenen C# entre en jeu. En l'intégrant avecIronPDF, vous pouvez vous assurer que vos tâches de génération de PDF sont à la fois réactives et efficaces. Dans cet article, nous explorerons l'importance de CancellationToken, pourquoi il s'associe bien avec IronPDF, et comment vous pouvez l'implémenter pour annuler des tâches avec élégance.

Qu'est-ce qu'un CancellationToken en C# ?

Le CancellationToken est une partie fondamentale de la programmation asynchrone en C#. Cela vous permet de signaler qu'une tâche doit être annulée, offrant aux développeurs un meilleur contrôle sur les opérations de longue durée. Ceci peut être particulièrement utile lors de l'exécution de tâches telles que la production de rapports ou de factures, où vous pourriez vouloir générer en continu des rapports dynamiques à partir de données jusqu'à ce que vous ayez atteint votre objectif, moment auquel vous pouvez utiliser des jetons d'annulation C# pour indiquer que l'opération doit être annulée, mettant ainsi fin au programme de manière gracieuse.

Comment cela fonctionne-t-il ?

Essentiellement, un CancellationToken est passé à une tâche ou à une méthode, qui vérifie périodiquement si une annulation a été demandée. Si tel est le cas, la tâche peut se terminer de manière élégante, libérant ainsi 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 à créer.

En utilisant des CancellationTokens, vous évitez les inconvénients potentiels liés aux tâches qui s’exécutent inutilement longtemps, tels que le gaspillage des ressources système et une mauvaise expérience utilisateur.

Jetons d'annulation interne

En C#, un jeton d'annulation interne fait référence à un jeton d'annulation qui est créé et géré au sein d'une classe ou d'une méthode spécifique, plutôt que d'être transmis depuis une source externe. Cela permet un contrôle plus précis de l'annulation des tâches dans le cadre d'un seul composant, lui permettant de surveiller et de répondre aux demandes d'annulation qui proviennent de manière interne.

Utiliser un jeton d'annulation interne est particulièrement utile dans les scénarios où vous souhaitez encapsuler la logique d'annulation sans l'exposer aux utilisateurs de votre classe, préservant ainsi une interface propre. Cette approche peut améliorer la modularité du code et faciliter la gestion des flux de travail asynchrones complexes tout en tirant parti de la flexibilité offerte par le cadre plus large CancellationToken.

Pourquoi utiliser un jeton d'annulation avec IronPDF ?

Lors de la génération de PDF, notamment dans les applications web ou les systèmes de reporting complexes, vous pourriez rencontrer des situations où un utilisateur initie une tâche, comme la création d'un fichier PDF volumineux, mais s'en va ensuite ou ne nécessite plus le résultat. Dans ces cas, vous souhaitez avoir l'option d'annuler le processus de génération de PDF pour éviter une charge inutile sur le serveur ou l'interface utilisateur.

Voici pourquoi l'utilisation de CancellationToken avec IronPDF est cruciale :

1. Prévenir les charges inutiles

Si un utilisateur n'a plus besoin du PDF qu'il a demandé, il n'y a aucune raison de continuer le processus. En utilisant CancellationToken, vous pouvez interrompre la tâche de génération de PDF, évitant ainsi une surcharge de vos serveurs et améliorant la performance globale de l'application.

2. Améliorer l'expérience utilisateur

Dans les applications de bureau, la génération de PDF peut se produire sur le thread de l'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 maintenir l'application réactive.

3. Améliorer la Scalabilité

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

Comment implémenter CancellationToken avec IronPDF

Maintenant que nous comprenons pourquoi CancellationToken est utile, examinons comment l'implémenter avec IronPDF.

Étape 1 : Configuration d'IronPDF dans votre projet

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

Via la console du gestionnaire de packages NuGet

Pourinstaller IronPDFen 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

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Via le gestionnaire de packages NuGet pour la solution

Ouvrez Visual Studio, allez dans "outils -> Gestionnaire de packages 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.

Image cassée Ajouter depuis Pixabay, sélectionner depuis vos fichiers ou glisser-déposer une image ici.

Une fois que vous avez installé IronPDF, il vous suffit d'ajouter l'instruction using correcte en tête de votre code pour commencer à utiliser IronPDF :

using IronPdf;

using IronPdf;

Imports IronPdf

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

Plongeons-nous dans la mise en œuvre réelle. Dans cet exemple, nous allons générer 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();
        // Creating our one 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();
        // Creating our one 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()
		' Creating our one 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 de la console

Sortie PDF

Dans cet exemple, nous 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 jeton d'annulation dans la méthode main en utilisant CancellationTokenSource.(), puis créez notre objet de jeton en passant la propriété Token de l'objet CancellationTokenSource** à celui-ci.
• ChromePdfRendererest utilisé à partir de la bibliothèque IronPDF pour rendre le contenu HTML dans un document PDF.
• La méthode GeneratePdfWithCancellation est asynchrone(asynchrone)et retourne une Tâche. Cette méthode accepte un CancellationToken.(jeton)pour gérer l'annulation de tâche via la demande d'annulation.
• Le CancellationToken nous permet d'annuler en toute sécurité des 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 le statut du jeton.
• Dans ce code, nous simulons une tâche longue avec des vérifications périodiques d'annulation. Le point clé est que nous vérifions manuellement l'annulation.(token.IsCancellationRequested)pendant le processus de génération de PDF, prêt à exécuter la méthode d'annulation si le jeton lui est transmis.
• Si l'utilisateur appuie sur une touche pour indiquer l'annulation du programme, la tâche s'arrête gracieusement et lance une OperationCanceledException, empêchant la finalisation de la génération PDF de manière appropriée et opportune.
• Le PDF résultant est enregistré sous "output.pdf" si aucune annulation ne s'est produite pour empêcher le programme d'exécuter le processus complet de la tâche.

Cas d'utilisation réels d'IronPDF avec CancellationToken

Il existe plusieurs situations pratiques où l'utilisation d'un ou plusieurs jetons d'annulation avec IronPDF peut améliorer les performances et l'expérience utilisateur de votre application. Voici quelques exemples :

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 mieux évoluer 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 l'exportation de grands ensembles de données sous forme de fichiers PDF. Si l'utilisateur change d'avis ou effectue une requête incorrecte, CancellationToken vous permet d'annuler la tâche en cours, évitant ainsi le gaspillage de ressources.

3. Services d'arrière-plan

Dans les services en arrière-plan ou les microservices, les tâches qui prennent un temps considérable, comme la génération de grands lots de PDF, peuvent être gérées de manière plus efficace 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.

Conclusion

Nous sommes arrivés à la fin de la discussion d'aujourd'hui sur l'utilisation de CancellationToken avec IronPDF. Vous serez capable de les intégrer dans vos projets PDF comme un professionnel.! Utilisation de C# CancellationToken avec IronPDFvous permet de créer des applications plus efficaces et réactives qui gèrent les tâches de génération de PDF avec élégance. Cette approche permet un modèle d'annulation coopérative, autorisant les tâches à vérifier les demandes d'annulation à des points sûrs pendant l'exécution, au lieu d'être interrompues de manière abrupte.

Que vous gériez des rapports de longue durée, une génération de PDF à la demande dans des applications web, ou des services en arrière-plan, intégrer un CancellationToken, ou plusieurs tokens simultanément, garantit que les tâches inutiles peuvent être annulées, évitant ainsi le gaspillage de ressources et améliorant l'expérience utilisateur.

Avec seulement quelques lignes de code, vous pouvez améliorer la scalabilité et la réactivité de votre application tout en donnant aux utilisateurs plus de contrôle sur leurs actions. Si vous n'avez pas encore exploré IronPDF, c'est le moment idéal pour essayer le essai gratuitet découvrez comment ses puissantes capacités de génération de PDF peuvent transformer vos projets C#.