W nowoczesnym tworzeniu oprogramowania kluczowe znaczenie ma efektywne zarządzanie długotrwałymi zadaniami, zwłaszcza w aplikacjach, w których często generowane są duże lub złożone pliki PDF. Programiści C# często polegają na IronPDF w celu płynnego tworzenia plików PDF, ale obsługa potencjalnie długotrwałych zadań generowania plików PDF wymaga sposobu na zarządzanie przerwami lub anulowaniami ze strony użytkownika.

W tym miejscu do gry wkracza CancellationToken w języku C#. Dzięki integracji z IronPDF możesz mieć pewność, że generowanie plików PDF będzie zarówno responsywne, jak i wydajne. W tym artykule omówimy znaczenie CancellationToken, dlaczego dobrze współpracuje z IronPDF oraz jak można go zaimplementować, aby łagodnie anulować zadania.

Czym jest CancellationToken w języku C#?

CancellationToken jest podstawowym elementem programowania asynchronicznego w języku C#. Pozwala to zasygnalizować, że zadanie powinno zostać anulowane, dając programistom większą kontrolę nad długotrwałymi operacjami. Może to być szczególnie pomocne podczas wykonywania zadań takich jak tworzenie raportów lub faktur, gdzie może zaistnieć potrzeba ciągłego generowania dynamicznych raportów na podstawie danych, aż do osiągnięcia docelowej kwoty, po czym można użyć tokenów anulowania w języku C#, aby wskazać, że operacja powinna zostać anulowana, co w elegancki sposób zakończy działanie programu.

Jak to działa?

Zasadniczo token CancellationToken jest przekazywany do zadania lub metody, która okresowo sprawdza, czy zgłoszono żądanie anulowania. W takim przypadku zadanie może zostać płynnie zakończone, co zwolni zasoby i poprawi responsywność aplikacji. Jest to szczególnie przydatne w przypadkach takich jak generowanie plików PDF, gdzie tworzenie złożonych dokumentów może zająć dużo czasu.

Korzystając z CancellationTokens, unikasz potencjalnych wad zadań, które działają niepotrzebnie długo, takich jak marnowanie zasobów systemowych i słabe wrażenia użytkownika.

Wewnętrzne tokeny anulowania

W języku C# wewnętrzny token anulowania odnosi się do tokenu anulowania, który jest tworzony i zarządzany w ramach konkretnej klasy lub metody, a nie przekazywany z zewnętrznego źródła. Pozwala to na dokładniejszą kontrolę nad anulowaniem zadań w ramach pojedynczego komponentu, umożliwiając mu monitorowanie i reagowanie na żądania anulowania pochodzące z wewnątrz.

Użycie wewnętrznego tokenu anulowania jest szczególnie przydatne w sytuacjach, gdy chcesz zamknąć logikę anulowania bez ujawniania jej użytkownikom klasy, zachowując w ten sposób przejrzysty interfejs. Takie podejście może zwiększyć modułowość kodu i ułatwić zarządzanie złożonymi, asynchronicznymi przepływami pracy, jednocześnie wykorzystując elastyczność zapewnianą przez szerszą strukturę CancellationToken.

Dlaczego warto używać tokenu anulowania w IronPDF?

Podczas generowania plików PDF, zwłaszcza w aplikacjach internetowych lub złożonych systemach raportowania, mogą wystąpić sytuacje, w których użytkownik zainicjuje zadanie, takie jak tworzenie dużego pliku PDF, a następnie opuści stronę lub nie będzie już potrzebował wyniku. W takich przypadkach potrzebna jest opcja anulowania procesu generowania pliku PDF, aby uniknąć niepotrzebnego obciążenia serwera lub interfejsu użytkownika.

Oto dlaczego użycie CancellationToken z IronPDF jest kluczowe:

1. Unikaj niepotrzebnego obciążenia

Jeśli użytkownik nie potrzebuje już zamówionego pliku PDF, nie ma powodu, aby proces był kontynuowany. Korzystając z CancellationToken, można zatrzymać zadanie generowania pliku PDF, zapobiegając nadmiernemu obciążeniu serwerów i poprawiając ogólną wydajność aplikacji.

2. Poprawa komfortu użytkowania

W aplikacjach desktopowych generowanie plików PDF może odbywać się w wątku interfejsu użytkownika, co może spowodować zawieszenie interfejsu, jeśli zadanie trwa długo. Dzięki zastosowaniu CancellationToken użytkownicy mogą anulować zadanie i zachować responsywność aplikacji.

3. Poprawa skalowalności

W aplikacjach internetowych, w których wielu użytkowników generuje pliki PDF jednocześnie, kluczowa jest skalowalność. CancellationToken pozwala bezpiecznie anulować niepotrzebne zadania, zwalniając zasoby w celu wydajnej obsługi innych żądań.

Jak zaimplementować CancellationToken w IronPDF

Teraz, gdy rozumiemy już, dlaczego CancellationToken jest przydatny, przejdźmy do omówienia sposobu jego wdrożenia w IronPDF.

Krok 1: Konfiguracja IronPDF w projekcie

Aby rozpocząć korzystanie z IronPDF, należy najpierw zainstalować program. Jeśli jest już zainstalowany, możesz przejść do następnej sekcji; W przeciwnym razie poniższe kroki opisują sposób instalacji biblioteki IronPDF.

Za pośrednictwem konsoli menedżera pakietów NuGet

Aby zainstalować IronPDF za pomocą konsoli menedżera pakietów NuGet, otwórz program Visual Studio i przejdź do konsoli menedżera pakietów. Następnie uruchom następujące polecenie:

Install-Package IronPdf

Za pośrednictwem menedżera pakietów NuGet dla Solution

Po uruchomieniu programu Visual Studio przejdź do "Narzędzia -> Menedżer pakietów NuGet -> Zarządzaj pakietami NuGet dla rozwiązania" i wyszukaj IronPDF. Teraz wystarczy wybrać projekt i kliknąć "Zainstaluj", a IronPDF zostanie dodany do projektu.

Po zainstalowaniu IronPDF wystarczy dodać odpowiednią instrukcję using na początku kodu, aby rozpocząć korzystanie z IronPDF:

using IronPdf;

using IronPdf;

Imports IronPdf

Imports IronPdf

Krok 2: Wykorzystanie tokenów anulowania w metodzie asynchronicznego generowania plików PDF

Przejdźmy do konkretnej realizacji. W tym przykładzie wygenerujemy prosty plik PDF z HTML przy użyciu IronPDF, ale z tokenem CancellationToken, który pozwala na anulowanie zadania w razie potrzeby.

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

Imports IronPdf
Imports System
Imports System.Threading
Imports System.Threading.Tasks

Public Class PdfGenerator
    Public Async Function GeneratePdfWithCancellation(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

            ' 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 ex 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(args As String()) As Task
        ' Create a CancellationTokenSource
        Dim cancellationTokenSource = New CancellationTokenSource()

        ' Create our cancellation token
        Dim token = cancellationTokenSource.Token

        ' Start the PDF generation task
        Dim pdfGenerator = 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 ex 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

Imports IronPdf
Imports System
Imports System.Threading
Imports System.Threading.Tasks

Public Class PdfGenerator
    Public Async Function GeneratePdfWithCancellation(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

            ' 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 ex 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(args As String()) As Task
        ' Create a CancellationTokenSource
        Dim cancellationTokenSource = New CancellationTokenSource()

        ' Create our cancellation token
        Dim token = cancellationTokenSource.Token

        ' Start the PDF generation task
        Dim pdfGenerator = 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 ex 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

Wynik konsoli

Wynik w formacie PDF

W tym przykładzie pokazujemy, jak użyć CancellationToken w programie napisanym w języku C#, aby anulować długotrwałe zadanie generowania pliku PDF za pomocą IronPDF. Kod jest podzielony na dwie części: proces generowania PDF (PdfGenerator klasa) oraz główną logikę programu (Program klasa).

• Klasa PdfGenerator: Ta klasa zawiera metodę, która symuluje generowanie pliku PDF, obsługując jednocześnie anulowanie za pomocą obiektu CancellationToken.
• Tworzymy źródło tokenu anulowania w metodzie main za pomocą CancellationTokenSource(), a następnie tworzymy obiekt tokenu, przekazując do niego właściwość Token obiektu CancellationTokenSource.
• ChromePdfRenderer jest wykorzystywany z biblioteki IronPDF do renderowania treści HTML do dokumentu PDF.
• Metoda GeneratePdfWithCancellation jest asynchroniczna (async) i zwraca Task. Ta metoda akceptuje CancellationToken (token) do obsługi anulowania zadań przez złożenie żądania anulującego.
• CancellationToken pozwala nam bezpiecznie anulować długotrwałe operacje. Jednak anulowanie ma charakter kooperacyjny, co oznacza, że samo zadanie musi okresowo sprawdzać status tokenu.
• W tym kodzie symulujemy długotrwałe zadanie z okresowymi kontrolami anulowania. Kluczowym punktem jest to, że ręcznie sprawdzamy anulowanie (token.IsCancellationRequested) podczas procesu generowania PDF, gotowi do uruchomienia metody anulującej, jeśli token zostanie do niej przekazany.
• Jeśli użytkownik naciśnie klawisz sygnalizujący anulowanie programu, zadanie zostanie płynnie zatrzymane i wygeneruje wyjątek OperationCanceledException, uniemożliwiając zakończenie generowania pliku PDF w odpowiedni i terminowy sposób.
• Wynikowy plik PDF jest zapisywany jako "output.pdf", o ile nie nastąpiło anulowanie, które uniemożliwiłoby programowi wykonanie całego procesu zadania.

Praktyczne przykłady zastosowania IronPDF z CancellationToken

Istnieje kilka praktycznych sytuacji, w których użycie jednego lub wielu tokenów anulowania w IronPDF może poprawić wydajność aplikacji i komfort użytkowania. Oto kilka przykładów:

1. Aplikacje internetowe

W aplikacjach internetowych użytkownicy często inicjują działania, takie jak generowanie raportów w formacie PDF. Jeśli jednak użytkownik opuści stronę lub zamknie przeglądarkę, system może to wykryć i użyć CancellationToken do zatrzymania procesu generowania pliku PDF.

HttpContext.Response.RegisterForDispose(CancellationTokenSource);

HttpContext.Response.RegisterForDispose(CancellationTokenSource);

HttpContext.Response.RegisterForDispose(CancellationTokenSource)

HttpContext.Response.RegisterForDispose(CancellationTokenSource)

Ta prosta implementacja pozwala serwerom internetowym na bardziej efektywne skalowanie poprzez niepoświęcanie zasobów na zadania, które nie są już potrzebne.

2. Raporty długoterminowe

W aplikacjach do raportowania użytkownicy mogą żądać eksportu dużych zbiorów danych do formatu PDF. Jeśli użytkownik zmieni zdanie lub wprowadzi nieprawidłowe zapytanie, CancellationToken pozwala na anulowanie zadania w trakcie jego wykonywania, zapobiegając marnowaniu zasobów.

3. Usługi w tle

W usługach działających w tle lub mikrousługach zadania wymagające znacznej ilości czasu, takie jak generowanie dużych partii plików PDF, można zarządzać bardziej efektywnie przy użyciu CancellationToken. Gdy usługa ma zostać wyłączona lub ograniczona, zadania w toku mogą zostać poprawnie anulowane, co gwarantuje, że żadne dane nie zostaną utracone ani uszkodzone.

Wnioski

Teraz, gdy dotarliśmy do końca dzisiejszej dyskusji na temat używania tokenów anulowania w IronPDF, będziesz w stanie wdrożyć je w swoich projektach PDF jak profesjonalista! Wykorzystanie C# CancellationToken z IronPDF pozwala tworzyć bardziej wydajne i responsywne aplikacje, które płynnie obsługują zadania związane z generowaniem plików PDF. Takie podejście umożliwia model kooperacyjnego anulowania, pozwalający zadaniom sprawdzać żądania anulowania w bezpiecznych punktach podczas wykonywania, zamiast nagłego przerywania.

Niezależnie od tego, czy zarządzasz długotrwałymi raportami, generowaniem plików PDF na żądanie w aplikacjach internetowych, czy usługami działającymi w tle, zastosowanie tokenu CancellationToken lub wielu tokenów jednocześnie gwarantuje, że niepotrzebne zadania mogą zostać anulowane, co zapobiega marnowaniu zasobów i poprawia komfort użytkowania.

Wystarczy kilka wierszy kodu, aby poprawić skalowalność i responsywność aplikacji, dając jednocześnie użytkownikom większą kontrolę nad ich działaniami. Jeśli jeszcze nie zapoznałeś się z IronPDF, teraz jest idealny moment, aby wypróbować bezpłatną wersję próbną i odkryć, jak jego potężne możliwości generowania plików PDF mogą zmienić Twoje projekty w języku C#.