C# İptal Tokeni (Geliştiriciler İçin Nasıl Çalışır)

Nasıl Çalışır?

Özetle, bir CancellationToken, bir göreve veya yönteme geçilir ve iptalin istenip istenmediğini periyodik olarak kontrol eder. Eğer öyleyse, görev nazikçe sona erebilir, kaynakları serbest bırakır ve uygulamanızın duyarlılığını artırır. Bu, karmaşık belgelerin oluşturulmasının biraz zaman alabileceği PDF oluşturma gibi durumlarda özellikle kullanışlıdır.

CancellationTokens kullanarak, gereksiz yere uzun süren görevlerin olası dezavantajlarından, sistem kaynaklarının israfı ve kötü kullanıcı deneyimi gibi, kaçınırsınız.

Dahili İptal Tokenleri

C#'ta, dahili bir iptal tokeni, belirli bir sınıf veya yöntemde oluşturulan ve yönetilen bir iptal tokenine atıfta bulunur, dış bir kaynaktan geçilmek yerine. Bu, tek bir bileşenin kapsamı içinde görev iptali üzerinde daha ince bir kontrol sağlar ve bu bileşen içinden kaynaklanan iptal taleplerini izleme ve bunlara cevap verme olanağı tanır.

Dahili bir iptal tokeni kullanmak, özellikle iptal mantığını sınıfınızın tüketicilerine açık hale getirmeden kapsamak istediğiniz senaryolarda yararlıdır ve böylece temiz bir arayüzü korur. Bu yaklaşım, kodun modülerliğini artırabilir ve geniş CancellationToken çerçevesi tarafından sağlanan esneklikten yararlanırken karmaşık eşzamanlı iş akışlarını yönetmeyi kolaylaştırabilir.

1. Gereksiz Yükten Önleyin

Bir kullanıcı talep ettiği PDF'ye artık ihtiyaç duymuyorsa, işlemin devam etmesinin bir anlamı yoktur. CancellationToken kullanarak, PDF oluşturma görevini durdurarak sunucularınızdaki fazla yükü önleyebilir ve genel uygulama performansını artırabilirsiniz.

2. Kullanıcı Deneyimini Geliştirin

Masaüstü uygulamalarında, PDF oluşturma UI iş parçacığında gerçekleşebilir ve bu, görevin uzun sürmesi durumunda kullanıcı arayüzünü kilitleyebilir. CancellationToken ekleyerek, kullanıcılar görevi iptal edebilir ve uygulamayı duyarlı tutabilir.

3. Ölçeklenebilirliği Artırın

Çok sayıda kullanıcının aynı anda PDF oluşturduğu web uygulamalarında ölçeklenebilirlik çok önemlidir. CancellationToken, gereksiz görevleri güvenli bir şekilde iptal etmenize ve diğer istekleri etkili bir şekilde yönetmek için kaynakları serbest bırakmanıza olanak tanır.

Adım 1: Projenize IronPDF'i Kurmak

IronPDF i kullanmaya başlamak için öncelikle yüklemeniz gerekecek. Eğer zaten yüklüyse, bir sonraki bölüme geçebilirsiniz; aksi takdirde, IronPDF kütüphanesinin nasıl yükleneceği aşağıdaki adımlarda açıklanmaktadır.

NuGet Paket Yöneticisi Konsolu Üzerinden

NuGet Paket Yöneticisi Konsolu'nu kullanarak IronPDF'i yüklemek için Visual Studio'yu açın ve Paket Yöneticisi Konsolu'na gidin. Ardından aşağıdaki komutu çalıştırın:

Install-Package IronPdf

Solution İçin NuGet Paket Yöneticisi Üzerinden

Visual Studio'yu açarak 'Araçlar -> NuGet Paket Yöneticisi -> Çözüm İçin NuGet Paketlerini Yönet' bölümüne gidin ve IronPDF'i arayın. Buradan, yapmanız gereken tek şey projenizi seçip 'Yükle'ye tıklamak ve IronPDF projenize eklenmiş olacak.

IronPDF'i yükledikten sonra, IronPDF'i kullanmaya başlamak için tek yapmanız gereken, kodunuzun en üstüne doğru 'using' deyimini eklemektir:

using IronPdf;

using IronPdf;

Imports IronPdf

Adım 2: Asenkron PDF Oluşturma Yönteminde İptal Tokenlerini Kullanma

Gerçek uygulamaya dalalım. Bu örnekte, basit bir PDF'yi HTML'den IronPDF kullanarak oluşturacağız, ancak, gerekirse görevin iptal edilmesini sağlayan bir CancellationToken ile.

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(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()

		' Create our 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

Konsol Çıkışı

PDF Çıktısı

Bu örnekte, IronPDF ile uzun süren bir PDF oluşturma görevini iptal etmek için bir CancellationToken kullanıldığını bir C# programında nasıl kullanacağınızı gösteriyoruz. Kod iki bölümde yapılandırılmıştır: PDF oluşturma süreci (PdfGenerator sınıfı) ve ana program mantığı (Program sınıfı).

• PdfGenerator Sınıfı: Bu sınıf, bir PDF dosyası oluşturmayı simule eden ve CancellationToken aracılığıyla iptali destekleyen bir yöntem içerir.
• Ana yöntemde CancellationTokenSource() kullanarak iptal token kaynağımızı oluşturuyoruz ve ardından token nesnemizi CancellationTokenSource'ın Token özelliğini ona geçirerek oluşturuyoruz.
• ChromePdfRenderer, HTML içeriğini bir PDF belgesine işlemek için IronPDF kütüphanesinden kullanılır.
• GeneratePdfWithCancellation yöntemi eşzamansız (async) olup bir Görev döndürür. Bu yöntem, iptal isteği yoluyla görev iptalini ele almak için bir CancellationToken (token) kabul eder.
• CancellationToken, uzun süreli işlemleri güvenli bir şekilde iptal etmemize olanak tanır. Ancak, iptal etmek işbirliğine dayalıdır, yani görevin kendisi token durumunu periyodik olarak kontrol etmelidir.
• Bu kodda, sürekliliği iptal için periyodik kontroller ile uzun bir görevi simule ediyoruz. Ana nokta, PDF oluşturma süreci sırasında iptali manuel olarak kontrol etmemiz (token.IsCancellationRequested) ve eğer token iletilirse iptal yöntemini çalıştırmaya hazır olmamızdır.
• Kullanıcı programın iptal edilmesini sinyal vermek için bir tuşa bastığında, görev zarif bir şekilde durur ve OperationCanceledException atar, PDF oluşturmanın uygun ve zamanlı bir şekilde tamamlanmasını önler.
• İptal gerçekleşmediğinde programı tüm görev sürecini çalıştırmaktan önlemek için sonuç PDF'i 'output.pdf' olarak kaydedilir.

1. Web Uygulamaları

Web uygulamasında, kullanıcılar genellikle PDF formatında rapor oluşturma gibi eylemleri başlatır. Ancak, kullanıcı sayfadan uzaklaştığında veya tarayıcıyı kapattığında, sistem bunu algılayabilir ve PDF oluşturma sürecini durdurmak için CancellationToken kullanabilir.

HttpContext.Response.RegisterForDispose(CancellationTokenSource);

HttpContext.Response.RegisterForDispose(CancellationTokenSource);

HttpContext.Response.RegisterForDispose(CancellationTokenSource)

Bu basit uygulama, artık ihtiyaç duyulmayan görevlere kaynak ayırmayı önleyerek web sunucularının daha etkili bir şekilde ölçeklenmesine olanak tanır.

2. Uzun Süreli Raporlar

Raporlama uygulamalarında, kullanıcılar büyük veri kümelerinin PDF olarak dışa aktarılmasını talep edebilir. Eğer kullanıcı fikrini değiştirirse veya yanlış bir sorgu yaparsa, CancellationToken, görevi yarıda durdurarak kaynak israfını önlemenizi sağlar.

3. Arka Plan Hizmetleri

Arka plan hizmetlerinde veya mikro hizmetlerde, büyük PDF gruplarının oluşturulması gibi önemli miktarda zaman alan görevler, CancellationToken kullanılarak daha verimli yönetilebilir. Hizmet kapatılacak veya ölçeklendirilecek olduğunda, devam eden görevler temiz bir şekilde iptal edilebilir, verilerin kaybolmasını veya bozulmasını önleyerek.