Test in einer Live-Umgebung
Test in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es brauchen.
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.
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.
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.
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.
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:
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.
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.
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.
Nun, da wir verstehen, warum CancellationToken nützlich ist, schauen wir uns an, wie man ihn mit IronPDF implementiert.
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
Ü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
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
Konsolenausgabe
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).
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:
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)
Diese einfache Implementierung ermöglicht es Webservern, effektiver zu skalieren, indem sie keine Ressourcen für Aufgaben verwenden, die nicht mehr benötigt werden.
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.
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.
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.
9 .NET API-Produkte für Ihre Bürodokumente