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

Wie funktioniert es?

Im Wesentlichen wird ein CancellationToken an eine Aufgabe oder Methode übergeben, die regelmäßig überprüft, ob ein Abbruch angefordert wurde. Wenn ja, kann die Aufgabe elegant beendet werden, wodurch Ressourcen freigegeben und die Reaktionsfähigkeit Ihrer Anwendung verbessert wird. Dies ist besonders nützlich bei der PDF-Erstellung, bei der komplexe Dokumente Zeit zur Erstellung benötigen könnten.

Durch die Verwendung von CancellationTokens vermeiden Sie die potenziellen Nachteile von Aufgaben, die unnötig lange laufen, wie beispielsweise verschwendete Systemressourcen und eine schlechte Benutzererfahrung.

Interne Storno-Token

In C# bezieht sich ein internes Abbruch-Token auf ein Abbruch-Token, welches innerhalb einer bestimmten Klasse oder Methode erstellt und verwaltet wird, anstatt von einer externen Quelle übergeben zu werden. Dies ermöglicht eine feinere Kontrolle über den Abbruch von Aufgaben im Rahmen einer einzelnen Komponente, wodurch es auf Abbruchanforderungen reagieren kann, die intern entstehen.

Ein internes Abbruch-Token zu verwenden, ist besonders nützlich in Szenarien, in denen Sie die Abbruchlogik kapseln möchten, ohne sie den Nutzern Ihrer Klasse auszusetzen, wodurch eine saubere Schnittstelle erhalten bleibt. Dieser Ansatz kann die Modularität des Codes verbessern und es einfacher machen, komplexe asynchrone Arbeitsabläufe zu verwalten, während die Flexibilität des breiteren CancellationToken-Rahmens genutzt wird.

1. Unnötige Last verhindern

Wenn ein Benutzer das angeforderte PDF nicht mehr benötigt, gibt es keinen Grund, den Prozess fortzusetzen. Durch die Nutzung von CancellationToken können Sie die PDF-Erstellungsaufgabe stoppen, wodurch übermäßige Belastungen Ihrer Server und eine Verbesserung der Gesamtleistung der Anwendung vermieden werden.

2. Verbesserung der Benutzerfreundlichkeit

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

3. Verbesserung der Skalierbarkeit

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

Schritt 1: Einrichten von IronPDF in Ihrem Projekt

Um IronPDF zu verwenden, müssen Sie es zuerst installieren. Wenn es bereits installiert ist, können Sie zum nächsten Abschnitt übergehen; Andernfalls behandeln die folgenden Schritte die Installation der IronPDF-Bibliothek.

Über die NuGet Package Manager Console

Um IronPDF über die NuGet-Paketmanager-Konsole zu installieren, öffnen Sie Visual Studio und navigieren Sie zur Paketmanager-Konsole. Führen Sie dann den folgenden Befehl aus:

Install-Package IronPdf

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

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

Sobald Sie IronPDF installiert haben, müssen Sie nur noch die richtige using-Anweisung zu Beginn Ihres Codes hinzufügen, um IronPDF verwenden zu können:

using IronPdf;

using IronPdf;

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

Lassen Sie uns in die eigentliche Implementierung eintauchen. In diesem Beispiel werden wir ein einfaches PDF aus HTML erstellen, indem wir IronPDF verwenden, jedoch mit einem CancellationToken, das erlaubt, 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();

        // 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.");
    }
}

Konsolenausgabe

PDF-Ausgabe

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

• Klasse PdfGenerator: Diese Klasse enthält eine Methode, die das Erzeugen einer PDF-Datei simuliert und die Unterstützung des Abbruchs mittels eines CancellationToken unterstützt.
• Wir erstellen unsere Abbruch-Token-Quelle in der main-Methode mithilfe von CancellationTokenSource() und erstellen dann unser Token-Objekt, indem wir die Eigenschaft Token der CancellationTokenSource an das Objekt übergeben.
• ChromePdfRenderer wird aus der IronPDF-Bibliothek verwendet, um HTML-Inhalte in ein PDF-Dokument zu rendern.
• Die Methode GeneratePdfWithCancellation ist asynchron (async) und gibt eine Aufgabe zurück. Diese Methode akzeptiert ein CancellationToken (token), um den Abbruch der Aufgabe durch die Abbruchanforderung zu handhaben.
• Das CancellationToken erlaubt uns, lang andauernde Operationen sicher abzubrechen. Der Abbruch ist jedoch kooperativ, was bedeutet, dass die Aufgabe selbst regelmäßig den Token-Status überprüfen muss.
• In diesem Code simulieren wir eine lange Aufgabe mit regelmäßigen Abbruchüberprüfungen. Der wichtigste Punkt ist, dass wir manuell auf Abbruch überprüfen (token.IsCancellationRequested) während des PDF-Erstellungsprozesses, um bereit zu sein, die Abbruchmethode auszuführen, wenn das Token an sie übergeben wird.
• Wenn der Benutzer eine Taste drückt, um den Abbruch des Programms zu signalisieren, stoppt die Aufgabe elegant und wirft eine OperationCanceledException, wodurch das vollständige Generieren der PDF-Datei auf angemessene und rechtzeitige Weise verhindert wird.
• Das resultierende PDF wird als "output.pdf" gespeichert, falls kein Abbruch erfolgt ist, um zu verhindern, dass das Programm den vollständigen Aufgabenprozess ausführt.

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 nutzen, um den PDF-Erstellungsprozess zu stoppen.

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 widmen, die nicht mehr benötigt werden.

2. Langlaufende Berichte

In Berichtsanwendungen könnten Benutzer große Datensätze zum Exportieren als PDF anfordern. Wenn der Benutzer seine Meinung ändert oder eine falsche Anfrage stellt, ermöglicht CancellationToken Ihnen, die Aufgabe auf halbem Weg abzubrechen, um Ressourcenverschwendung zu verhindern.

3. Hintergrunddienste

In Hintergrunddiensten oder Microservices können Aufgaben, die einen erheblichen Zeitaufwand erfordern, wie die Generierung großer PDF-Batches, effizienter verwaltet werden, indem CancellationToken verwendet wird. Wenn der Dienst heruntergefahren oder das System verkleinert werden soll, können Aufgaben, die gerade in Bearbeitung sind, sauber abgebrochen werden, um sicherzustellen, dass keine Daten verloren gehen oder beschädigt werden.