.NET-HILFE

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

Veröffentlicht 15. Dezember 2024
Teilen Sie:

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.

Dies ist der Ort, an dem dieCancellationTokenin C# ins Spiel kommt. Durch die Integration mitIronPDF, können Sie sicherstellen, dass Ihre PDF-Erstellungsaufgaben 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 verschwendete Systemressourcen und eine schlechte Benutzererfahrung.

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 dennoch 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:

1. Unnötige Belastung vermeiden

Wenn ein Benutzer das von ihm angeforderte PDF nicht mehr benötigt, gibt es keinen Grund, den Vorgang fortzusetzen. Durch die Nutzung von CancellationToken können Sie die PDF-Generierungsaufgabe abbrechen, wodurch eine übermäßige Belastung Ihrer Server vermieden und die Gesamtleistung der Anwendung verbessert wird.

2. Benutzererlebnis verbessern

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. Verbesserung der Skalierbarkeit

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

Nun, da wir verstehen, warum CancellationToken nützlich ist, schauen wir uns an, wie man ihn mit IronPDF implementiert.

Schritt 1: Einrichten von IronPDF in Ihrem Projekt

Um mit der Verwendung vonIronPDF, 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

AnIronPDF installierenVerwenden Sie die NuGet-Paket-Manager-Konsole, öffnen Sie Visual Studio und navigieren Sie zur Paket-Manager-Konsole. 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
VB   C#

Ü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.

Defektes Bild Von Pixabay hinzufügen, aus Ihren Dateien auswählen oder ein Bild hierher ziehen.

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
VB   C#

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

Lass uns in die tatsächliche Implementierung eintauchen. In diesem Beispiel erstellen wir ein einfaches PDF aus HTML mit IronPDF, allerdings 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
VB   C#

Konsolenausgabe

C# Cancellationtoken(Wie es für Entwickler funktioniert): Abbildung 2 - Konsolenausgabe

PDF-Ausgabe

C# CancellationToken (Wie es für Entwickler funktioniert): Abbildung 3 - PDF-Ausgabe

In diesem Beispiel demonstrieren wir, wie ein CancellationToken in einem C#-Programm verwendet wird, um eine lang andauernde PDF-Erstellungsaufgabe mit IronPDF abzubrechen. Der Code ist in zwei Teile gegliedert: der PDF-Generierungsprozess(PdfGenerator-Klasse)und die Hauptprogrammlogik(Programmklasse).

  • Klasse PdfGenerator: Diese Klasse enthält eine Methode, die das Erzeugen einer PDF-Datei simuliert und dabei die Stornierung über einen CancellationToken unterstützt.
  • Wir erstellen unsere Abbruch-Token-Quelle in der main-Methode mithilfe von CancellationTokenSource.(), und dann erstellen wir unser Token-Objekt, indem wir die Token-Eigenschaft** des CancellationTokenSource an es übergeben.
  • ChromePdfRendererwird aus der IronPDF-Bibliothek verwendet, um HTML-Inhalte in ein PDF-Dokument zu rendern.
  • Die GeneratePdfWithCancellation-Methode ist asynchron.(asynchron)und gibt eine Task zurück. Diese Methode akzeptiert ein CancellationToken.(Token)um die Aufgabenstornierung durch die Stornierungsanforderung zu bearbeiten.
  • 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 manuell auf Stornierung prüfen.(token.IsCancellationRequested)während des PDF-Erstellungsprozesses bereit, die Abbruchmethode auszuführen, wenn das Token ü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 auf angemessene und rechtzeitige Weise abgeschlossen wird.
  • Die resultierende PDF-Datei wird als "output.pdf" gespeichert, wenn keine Stornierung erfolgt ist, um zu verhindern, dass das Programm den vollständigen Aufgabenprozess ausführt.

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:

1. Webanwendungen

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

HttpContext.Response.RegisterForDispose(CancellationTokenSource);
HttpContext.Response.RegisterForDispose(CancellationTokenSource);
HttpContext.Response.RegisterForDispose(CancellationTokenSource)
VB   C#

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. Langandauernde Berichte

In Berichtsanwendungen könnten Benutzer große Datensätze zum Exportieren als PDFs anfordern. Wenn der Benutzer seine Meinung ändert oder eine falsche Anfrage stellt, ermöglicht CancellationToken Ihnen, die Aufgabe in der Mitte abzubrechen und Ressourcenverschwendung zu vermeiden.

3. Hintergrunddienste

In Hintergrunddiensten oder Microservices können Aufgaben, die erheblich viel Zeit in Anspruch nehmen, wie das Erstellen großer PDF-Stapel, 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 angekommen. Sie werden in der Lage sein, diese wie ein Profi in Ihre PDF-Projekte zu implementieren.! Verwendung von C# CancellationToken mitIronPDFermöglicht es Ihnen, effizientere, reaktionsschnelle Anwendungen zu erstellen, die PDF-Generierungsaufgaben mühelos bewältigen. 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.

Egal, ob Sie lange laufende Berichte verwalten, PDF-Generierung auf Abruf in Webanwendungen oder Hintergrunddienste, die Einbindung eines CancellationToken oder mehrerer Token gleichzeitig stellt sicher, dass unnötige Aufgaben abgebrochen werden können, um Ressourcenverschwendung zu verhindern und die Benutzererfahrung zu verbessern.

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 es auszuprobieren.kostenlos testenund entdecken Sie, wie seine leistungsstarken PDF-Erstellungsfunktionen Ihre C#-Projekte transformieren können.

< PREVIOUS
C# Select Case (Wie es für Entwickler funktioniert)
NÄCHSTES >
math.max C# (Wie es für Entwickler funktioniert)

Sind Sie bereit, loszulegen? Version: 2024.12 gerade veröffentlicht

Gratis NuGet-Download Downloads insgesamt: 11,810,873 Lizenzen anzeigen >