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

Nasıl çalışır?

Özünde, bir CancellationToken bir göreve veya yönteme iletilir ve iptal isteğinin olup olmadığını belirli aralıklarla kontrol eder. Eğer öyleyse, görev zarifçe sonlanabilir, kaynakları serbest bırakır ve uygulamanızın duyarlılığını artırır. Bu, özellikle karmaşık belgelerin oluşturulmasının zaman alabileceği PDF oluşturma gibi durumlarda kullanışlıdır.

CancellationTokens kullanarak, gereksiz yere uzun süren görevlerin potansiyel dezavantajlarından, sistem kaynaklarının israfı veya zayıf bir kullanıcı deneyiminden kaçınabilirsiniz.

Dahili İptal Tokenleri

C# dilinde, dahili bir iptal simgesi, belirli bir sınıf veya yöntem içinde oluşturulan ve yönetilen, dış bir kaynaktan gelmek yerine oluşturulan ve yönetilen bir iptal simgesini ifade eder. Bu, tek bir bileşenin kapsamı içinde görev iptali üzerinde daha ince bir kontrol sağlar, içsel olarak başlayan iptal isteklerini izleme ve yanıt vermeyi mümkün kılar.

Dahili bir iptal simgesi kullanmak, iptal mantığını sınıfınızın tüketicilerine açığa çıkarmadan kapsüllendirmek istediğiniz senaryolarda özellikle kullanışlıdır, bu sayede temiz bir arayüz korur. Bu yaklaşım, kodun modülerliğini artırabilir ve daha geniş CancellationToken çerçevesinin sağladığı esnekliği hala kullanarak, karmaşık eş zamanlı iş akışlarını yönetmeyi kolaylaştırabilir.

1. Gereksiz Yükü Önlemek

Bir kullanıcı, istekte bulunduğu PDF'yi artık istemiyorsa, işlemin devam etmesi için bir neden yoktur. CancellationToken kullanarak PDF oluşturma görevini durdurabilir, sunucularınız üzerindeki fazla yükü önleyebilir ve genel uygulama performansını artırabilirsiniz.

2. Kullanıcı Deneyimini Geliştirmek

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

3. Ölçeklenebilirliği Artırmak

Ç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üvenle iptal etmenizi sağlar, kaynakları diğer istekleri verimli bir şekilde ele almak için serbest bırakır.

Step 1: Projenizde IronPDF'yi Kurma

IronPDF kullanmaya başlamak için, önce onu yüklemeniz gerekecek. Zaten yüklenmişse, bir sonraki bölüme geçebilirsiniz; aksi takdirde, aşağıdaki adımlar IronPDF kütüphanesinin nasıl yükleneceğini kapsar.

NuGet Package Manager Konsolu Üzerinden

NuGet Paket Yöneticisi Konsolu'nu kullanarak IronPDF'yi 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

NuGet Package Manager for Solution aracılığıyla

Visual Studio'yu açarak, "Tools -> NuGet Package Manager -> Manage NuGet Packages for Solution" yolundan IronPDF'yi arayın. Buradan, tek yapmanız gereken projenizi seçip "Install"a tıklamanız ve IronPDF projenize eklenecektir.

IronPDF'yi yükledikten sonra hemen kullanmaya başlamak için tek yapmanız gereken kodun başına doğru using ifadesini eklemektir:

using IronPdf;

using IronPdf;

Imports IronPdf

Step 2: Asynchronous PDF Generation Methodda Cancellation Tokens Kullanma

Gelin gerçek bir uygulamayı keşfedelim. Bu örnekte, basit bir PDF'i HTML'den IronPDF kullanarak oluşturacağız, ancak CancellationToken ile gerektiğinde görevin iptal edilmesine olanak tanıyacağız.

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 Çıkışı

Bu örnekte, IronPDF ile uzun süren bir PDF oluşturma görevini iptal etmek için C# programında bir CancellationToken kullanmayı 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ı).

• Class PdfGenerator: Bu sınıf, bir PDF dosyası oluşturmayı simüle eden, bir CancellationToken kullanarak iptali destekleyen bir yöntem içerir.
• main metodunda CancellationTokenSource() kullanarak iptal simgesi kaynağımızı oluşturuyoruz ve ardından CancellationTokenSource 'ın Token özelliğini ona ileterek simge nesnemizi oluşturuyoruz.
• HTML içeriğini bir PDF belgesine renderlamak için IronPDF kütüphanesinden ChromePdfRenderer kullanılır.
• GeneratePdfWithCancellation metodu asenkron (async) çalışır ve bir Task döndürür. Bu metod, iptal talebi ile görev iptalini yönetmek için bir CancellationToken (token) kabul eder.
• CancellationToken, uzun süren işlemleri güvenle iptal etmemize olanak tanır. Ancak, iptal işbirlikçidir, yani görevin kendisi düzenli aralıklarla simge durumunu kontrol etmelidir.
• Bu kodda, periyodik iptal kontrollerine sahip uzun bir görev simüle ediyoruz. Ana nokta, PDF oluşturma süreci sırasında iptal (token.IsCancellationRequested) için manuel kontrol ettiğimiz ve token kendisine verildiğinde iptal metodunu çalıştırmaya hazır olduğumuzdur.
• Kullanıcı, programın iptalini belirtmek için bir tuşa bastığında, görev zarif bir şekilde durur ve bir OperationCanceledException fırlatır, PDF oluşturma işleminin uygun ve zamanında tamamlanmasını önler.
• İptalin gerçekleşmediği durumda, tamamlanmış görev sürecinin program tarafından çalıştırılmasını önlemek için üretilen PDF 'output.pdf' olarak kaydedilir.

1. Web Uygulamaları

Web uygulamasında, kullanıcılar genellikle PDF formatında rapor oluşturma gibi eylemleri başlatırlar. Ancak, kullanıcı sayfadan ayrılır veya tarayıcıyı kapatırsa, 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ırmayarak 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 setlerinin PDF olarak dışa aktarılmasını talep edebilir. Kullanıcı fikrini değiştirdiğinde veya yanlış bir sorgu yaptığında, CancellationToken, görevi yarıda iptal etmenize izin verir, bu da kaynak israfını önler.

3. Arka Plan Servisleri

Arka plan hizmetleri veya mikro hizmetlerde, büyük PDF grupları oluşturmak gibi önemli miktarda zaman alan görevler, CancellationToken kullanılarak daha verimli bir şekilde yönetilebilir. Hizmet kapatılmak veya ölçeklendirilmek üzereyken, devam eden görevler temiz bir şekilde iptal edilebilir, böylece veri kaybı veya bozulma olmaz.