C# Cancellationtoken (Wie es für Entwickler funktioniert)

In der modernen Softwareentwicklung ist das effiziente Management von lang andauernden Aufgaben entscheidend, insbesondere in Anwendungen, bei denen die Erstellung großer oder komplexer PDF-Dateien üblich ist. C#-Entwickler verlassen sich oft auf IronPDF für nahtlose PDF-Erstellung, aber die Handhabung potenziell langwieriger PDF-Generierungsaufgaben erfordert eine Möglichkeit, Benutzerunterbrechungen oder -abbrüche zu verwalten.

Hier kommt der CancellationToken in C# ins Spiel. Durch die Integration mit IronPDF können Sie sicherstellen, dass Ihre PDF-Generierungsaufgaben sowohl reaktionsschnell als auch effizient sind. In diesem Artikel werden wir die Bedeutung von CancellationToken untersuchen, warum es gut zu IronPDF passt und wie Sie es implementieren können, um Aufgaben elegant abzubrechen.

Was ist ein CancellationToken in C#?

Der CancellationToken ist ein grundlegender Bestandteil der asynchronen Programmierung in C#. Es ermöglicht Ihnen, anzuzeigen, dass eine Aufgabe abgebrochen werden sollte, und gibt Entwicklern mehr Kontrolle über lang andauernde Operationen. Dies kann besonders nützlich sein, wenn Aufgaben wie das Erstellen von Berichten oder Rechnungen ausgeführt werden, bei denen Sie kontinuierlich dynamische Berichte aus Daten generieren möchten, bis Sie Ihre Zielmenge erreicht haben. An diesem Punkt können Sie C# Abbruch-Token verwenden, um anzugeben, dass der Vorgang abgebrochen werden soll, was das Programm auf elegante Weise beendet.

Wie funktioniert das?

Im Wesentlichen wird ein CancellationToken an eine Aufgabe oder Methode übergeben, die regelmäßig überprüft, ob eine Stornierung angefordert wurde. Falls ja, kann die Aufgabe reibungslos beendet werden, wodurch Ressourcen freigegeben und die Reaktionsfähigkeit Ihrer Anwendung verbessert wird. Dies ist besonders nützlich in Fällen wie der PDF-Erstellung, bei denen die Erstellung komplexer Dokumente Zeit in Anspruch nehmen kann.

Durch die Verwendung von CancellationTokens vermeiden Sie die potenziellen Nachteile von Aufgaben, die unnötig lange laufen, wie beispielsweise verschwendete Systemressourcen und ein schlechtes Benutzererlebnis.

Interne Abbruch-Token

In C# bezieht sich ein interner Abbruchtoken auf ein Abbruchtoken, das innerhalb einer bestimmten Klasse oder Methode erstellt und verwaltet wird, anstatt von einer externen Quelle übergeben zu werden. Dies ermöglicht eine genauere Steuerung der Aufgabenabbruch innerhalb des Bereichs einer einzigen Komponente, wodurch sie in der Lage ist, Abbruchanforderungen, die intern entstehen, zu überwachen und darauf zu reagieren.

Die Verwendung eines internen Abbruch-Tokens ist besonders nützlich in Szenarien, in denen Sie Abbruchlogik kapseln möchten, ohne sie den Nutzern Ihrer Klasse offenzulegen, und dadurch eine saubere Schnittstelle beibehalten. Dieser Ansatz kann die Modularität des Codes verbessern und die Verwaltung komplexer asynchroner Workflows erleichtern, während weiterhin die Flexibilität des umfassenderen CancellationToken-Frameworks genutzt wird.

Warum einen Abbruch-Token mit IronPDF verwenden?

Beim Generieren von PDFs, insbesondere in Webanwendungen oder komplexen Berichtssystemen, können Sie auf Situationen stoßen, in denen ein Benutzer eine Aufgabe initiiert, wie beispielsweise das Erstellen einer großen PDF-Datei, aber dann weg navigiert oder das Ergebnis nicht mehr benötigt. In diesen Fällen möchten Sie die Option haben, den PDF-Erstellungsprozess zu stornieren, um unnötige Belastung des Servers oder der Benutzeroberfläche zu vermeiden.

Hier ist der Grund, warum die Verwendung von CancellationToken mit IronPDF entscheidend ist:

Vermeiden Sie unnötige Belastung

Wenn ein Benutzer das von ihm angeforderte PDF nicht mehr benötigt, gibt es keinen Grund, den Vorgang fortzusetzen. Durch die Verwendung von CancellationToken können Sie die PDF-Generierungsaufgabe anhalten, um eine Überlastung Ihrer Server zu verhindern und die Gesamtleistung der Anwendung zu verbessern.

2. Verbessern Sie das Benutzererlebnis

In Desktop-Anwendungen kann die PDF-Erzeugung im UI-Thread erfolgen, was die Benutzeroberfläche blockieren könnte, wenn die Aufgabe lange dauert. Durch die Einbindung von CancellationToken können Benutzer die Aufgabe abbrechen und die Anwendung reaktionsfähig halten.

3. Skalierbarkeit verbessern

In Webanwendungen, bei denen zahlreiche Benutzer gleichzeitig PDFs erzeugen, ist Skalierbarkeit entscheidend. CancellationToken ermöglicht es Ihnen, unnötige Aufgaben sicher abzubrechen, wodurch Ressourcen freigesetzt werden, um andere Anfragen effizient zu bearbeiten.

So implementieren Sie CancellationToken mit IronPDF

Da wir nun verstehen, warum der CancellationToken nützlich ist, gehen wir durch, wie er mit IronPDF implementiert wird.

Schritt 1: Einrichten von IronPDF in Ihrem Projekt

Um mit der Verwendung von IronPDF zu beginnen, müssen Sie es zuerst installieren. Wenn es bereits installiert ist, können Sie zum nächsten Abschnitt übergehen, andernfalls decken die folgenden Schritte ab, wie die IronPDF-Bibliothek installiert wird.

Über die NuGet-Paket-Manager-Konsole

Um IronPDF zu installieren, öffnen Sie Visual Studio und navigieren Sie zur Paket-Manager-Konsole, um den NuGet-Paket-Manager zu verwenden. Führen Sie dann den folgenden Befehl aus:

Install-Package IronPdf

Install-Package IronPdf

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

Über den NuGet-Paket-Manager für die Lösung

Öffnen Sie Visual Studio, gehen Sie zu "Tools -> NuGet-Paket-Manager -> NuGet-Pakete für die Lösung verwalten" und suchen Sie nach IronPDF. Von hier aus müssen Sie nur Ihr Projekt auswählen und auf „Installieren“ klicken, dann wird IronPDF zu Ihrem Projekt hinzugefügt.

Sobald Sie IronPDF installiert haben, müssen Sie nur noch die korrekte Using-Anweisung am Anfang Ihres Codes hinzufügen, um IronPDF verwenden zu können:

using IronPdf;

using IronPdf;

Imports IronPdf

Schritt 2: Verwendung von Abbruch-Token in einer asynchronen PDF-Generierungsmethode

Lass uns in die tatsächliche Implementierung eintauchen. In diesem Beispiel werden wir ein einfaches PDF aus HTML mit IronPDF erstellen, jedoch mit einem CancellationToken, das es ermöglicht, die Aufgabe bei Bedarf abzubrechen.

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

Konsolenausgabe

PDF-Ausgabe

In diesem Beispiel zeigen wir, wie man ein CancellationToken in einem C#-Programm verwendet, um eine lang andauernde PDF-Generierungsaufgabe mit IronPDF abzubrechen. Der Code ist in zwei Teile gegliedert: den PDF-Generierungsprozess (PdfGenerator-Klasse) und die Hauptprogrammlogik (Program-Klasse).

• Klasse PdfGenerator: Diese Klasse enthält eine Methode, die das Erstellen einer PDF-Datei simuliert und die Stornierung über ein CancellationToken unterstützt.
• Wir erstellen unsere Abbruchtokenquelle in der main-Methode mit CancellationTokenSource() und erstellen dann unser Token-Objekt, indem wir die Token-Eigenschaft der CancellationTokenSource übergeben.
• ChromePdfRenderer wird aus der IronPDF-Bibliothek verwendet, um HTML-Inhalte in ein PDF-Dokument zu rendern.
• Die GeneratePdfWithCancellation-Methode ist asynchron (async) und gibt eine Task zurück. Diese Methode akzeptiert ein CancellationToken (Token), um die Aufgabenabbruch durch die Abbruchanforderung zu handhaben.
• Der CancellationToken ermöglicht es uns, lang andauernde Operationen sicher abzubrechen. Die Kündigung ist jedoch kooperativ, was bedeutet, dass die Aufgabe selbst den Status des Tokens regelmäßig überprüfen muss.
• In diesem Code simulieren wir eine lange Aufgabe mit regelmäßigen Abbruchprüfungen. Der entscheidende Punkt ist, dass wir während des PDF-Erstellungsprozesses manuell auf eine Stornierung (token.IsCancellationRequested) überprüfen, um die Abbruchmethode auszuführen, wenn das Token an sie übergeben wird.
• Wenn der Benutzer eine Taste drückt, um die Beendigung des Programms zu signalisieren, stoppt die Aufgabe ordnungsgemäß und wirft eine OperationCanceledException, wodurch verhindert wird, dass die PDF-Erstellung angemessen und rechtzeitig abgeschlossen wird.
• Die resultierende PDF wird als "output.pdf" gespeichert, wenn keine Stornierung erfolgt ist, um das Programm daran zu hindern, den vollständigen Aufgabenprozess auszuführen.

Echte Anwendungsfälle von IronPDF mit CancellationToken

Es gibt mehrere praktische Situationen, in denen die Verwendung eines oder mehrerer Cancellation Tokens mit IronPDF die Leistung und Benutzererfahrung Ihrer Anwendung verbessern kann. Hier sind einige Beispiele:

Webanwendungen

In einer Webanwendung initiieren Benutzer häufig Aktionen wie das Erstellen von Berichten im PDF-Format. Falls der Benutzer jedoch die Seite verlässt oder den Browser schließt, kann das System dies erkennen und den CancellationToken verwenden, um den PDF-Erstellungsvorgang zu stoppen.

HttpContext.Response.RegisterForDispose(CancellationTokenSource);

HttpContext.Response.RegisterForDispose(CancellationTokenSource);

HttpContext.Response.RegisterForDispose(CancellationTokenSource)

Diese einfache Implementierung ermöglicht es Webservern, effektiver zu skalieren, indem sie keine Ressourcen für Aufgaben verwenden, die nicht mehr benötigt werden.

2. Länger laufende Berichte

In Berichtsanwendungen könnten Benutzer große Datensätze zum Exportieren als PDFs anfordern. Wenn der Benutzer seine Meinung ändert oder eine falsche Abfrage macht, ermöglicht der CancellationToken Ihnen, die Aufgabe unterwegs abzubrechen, um Ressourcenverschwendung zu verhindern.

3. Hintergrunddienste

In Hintergrunddiensten oder Mikroservices können Aufgaben, die eine beträchtliche Zeit in Anspruch nehmen, wie das Erstellen großer PDF-Batchs, effizienter mit CancellationToken verwaltet werden. Wenn der Dienst heruntergefahren oder reduziert wird, können laufende Aufgaben sauber abgebrochen werden, sodass keine Daten verloren gehen oder beschädigt werden.

Schlussfolgerung

Nun sind wir am Ende der heutigen Diskussion über die Verwendung von CancellationTokens mit IronPDF angelangt. Sie werden in der Lage sein, sie wie ein Profi in Ihre PDF-Projekte zu implementieren! Die Verwendung von C# CancellationToken mit IronPDF ermöglicht es Ihnen, effizientere und reaktionsfähigere Anwendungen zu erstellen, die PDF-Generierungsaufgaben elegant handhaben. Dieser Ansatz ermöglicht ein kooperatives Abbruchmodell, das es Aufgaben erlaubt, Abbruchanforderungen an sicheren Stellen während der Ausführung zu überprüfen, anstatt abrupt beendet zu werden.

Unabhängig davon, ob Sie lang andauernde Berichte verwalten, PDF-Erstellung auf Abruf in Webanwendungen durchführen oder Hintergrunddienste verwenden, stellt die Einbindung eines CancellationToken oder mehrerer Token gleichzeitig sicher, dass unnötige Aufgaben abgebrochen werden können. Dies verhindert verschwendete Ressourcen und verbessert das Benutzererlebnis.

Mit nur wenigen Codezeilen können Sie die Skalierbarkeit und Reaktionsfähigkeit Ihrer App verbessern und den Benutzern mehr Kontrolle über ihre Aktionen geben. Wenn Sie IronPDF noch nicht erkundet haben, ist jetzt der perfekte Zeitpunkt, um die kostenlose Testversion auszuprobieren und zu entdecken, wie seine leistungsstarken PDF-Generierungsmöglichkeiten Ihre C#-Projekte transformieren können.