C# SemaphoreSlim (Jak to dziala dla programistow)

SemaphoreSlim is a synchronization primitive in .NET that limits the number of threads that can access a particular resource or pool of resources concurrently. It is a lightweight version of the full Semaphore class, designed to work more efficiently in situations where a simpler, faster semaphore is sufficient.

Some benefits of using SemaphoreSlim are that the system overhead is reduced compared to Semaphore, it's ideal for managing limited resources (such as database connections or file access), and it supports asynchronous wait methods, making it well-suited for modern async/await programming patterns.

Code Example of Basic SemaphoreSlim Usage

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    // Semaphore count
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(3); // Limit to 3 concurrent threads.

    static async Task Main(string[] args)
    {
        // Start tasks that will wait on the semaphore.
        var tasks = new Task[5];

        for (int i = 0; i < tasks.Length; i++)
        {
            tasks[i] = Task.Run(() => AccessResource(i));
        }

        // Simulate some work in the main thread (e.g., initialization).
        Console.WriteLine("Main thread is preparing resources...");
        await Task.Delay(2000);  // Simulate initialization delay.

        // Main thread calls release, releases semaphore permits to allow waiting tasks to proceed.
        Console.WriteLine("Main thread releasing semaphore permits...");
        _semaphore.Release(2);  // Releases 2 permits, allowing up to 2 tasks to proceed.

        // Wait for all tasks to complete.
        await Task.WhenAll(tasks);
        Console.WriteLine("All tasks completed.");
    }

    static async Task AccessResource(int id)
    {
        Console.WriteLine($"Task {id} waiting to enter...");
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Current thread successfully entered by Task {id}.");
            await Task.Delay(1000); // Simulate work.
        }
        finally
        {
            Console.WriteLine($"Task {id} releasing.");
            _semaphore.Release();
        }
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    // Semaphore count
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(3); // Limit to 3 concurrent threads.

    static async Task Main(string[] args)
    {
        // Start tasks that will wait on the semaphore.
        var tasks = new Task[5];

        for (int i = 0; i < tasks.Length; i++)
        {
            tasks[i] = Task.Run(() => AccessResource(i));
        }

        // Simulate some work in the main thread (e.g., initialization).
        Console.WriteLine("Main thread is preparing resources...");
        await Task.Delay(2000);  // Simulate initialization delay.

        // Main thread calls release, releases semaphore permits to allow waiting tasks to proceed.
        Console.WriteLine("Main thread releasing semaphore permits...");
        _semaphore.Release(2);  // Releases 2 permits, allowing up to 2 tasks to proceed.

        // Wait for all tasks to complete.
        await Task.WhenAll(tasks);
        Console.WriteLine("All tasks completed.");
    }

    static async Task AccessResource(int id)
    {
        Console.WriteLine($"Task {id} waiting to enter...");
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Current thread successfully entered by Task {id}.");
            await Task.Delay(1000); // Simulate work.
        }
        finally
        {
            Console.WriteLine($"Task {id} releasing.");
            _semaphore.Release();
        }
    }
}

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

Friend Class Program
	' Semaphore count
	Private Shared _semaphore As New SemaphoreSlim(3) ' Limit to 3 concurrent threads.

	Shared Async Function Main(ByVal args() As String) As Task
		' Start tasks that will wait on the semaphore.
		Dim tasks = New Task(4){}

		For i As Integer = 0 To tasks.Length - 1
			tasks(i) = Task.Run(Function() AccessResource(i))
		Next i

		' Simulate some work in the main thread (e.g., initialization).
		Console.WriteLine("Main thread is preparing resources...")
		Await Task.Delay(2000) ' Simulate initialization delay.

		' Main thread calls release, releases semaphore permits to allow waiting tasks to proceed.
		Console.WriteLine("Main thread releasing semaphore permits...")
		_semaphore.Release(2) ' Releases 2 permits, allowing up to 2 tasks to proceed.

		' Wait for all tasks to complete.
		Await Task.WhenAll(tasks)
		Console.WriteLine("All tasks completed.")
	End Function

	Private Shared Async Function AccessResource(ByVal id As Integer) As Task
		Console.WriteLine($"Task {id} waiting to enter...")
		Await _semaphore.WaitAsync()

		Try
			Console.WriteLine($"Current thread successfully entered by Task {id}.")
			Await Task.Delay(1000) ' Simulate work.
		Finally
			Console.WriteLine($"Task {id} releasing.")
			_semaphore.Release()
		End Try
	End Function
End Class

During the operation of a program, the semaphore's count can dynamically reach zero threads when all available permits have been acquired by threads. This state indicates that the maximum allowed concurrent accesses have been reached.

If you wanted, you could set the initial and maximum number of threads, starting the initial semaphore count at zero and then using a separate initialization task that increases the semaphore count when the resource is ready, allowing your chosen number of threads to proceed. When the semaphore count is zero, threads will wait when it's trying to enter the semaphore, this is referred to as "block waiting".

You could keep track of the previous semaphore count to adjust the semaphore's behavior based on the previous count. You can then manipulate the semaphore accordingly (e.g., by releasing or waiting). As the threads release, the semaphore count is decreased.

Wynik konsoli

When you're using SemaphoreSlim, you can effectively control access to PDF generation tasks. This ensures that your application does not attempt to generate too many PDFs simultaneously, which could impact performance or cause failures.

The following example code demonstrates the basic usage of SemaphoreSlim with IronPDF.

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(2); // Limit to 2 concurrent threads.

    static async Task Main(string[] args)
    {
        var tasks = new Task[5];

        for (int i = 0; i < tasks.Length; i++)
        {
            string htmlContent = $"<h1>PDF Document {i}</h1><p>This is a sample PDF content for task {i}.</p>";
            string outputPath = $"output_{i}.pdf";

            // Start multiple tasks to demonstrate controlled concurrency.
            tasks[i] = GeneratePdfAsync(htmlContent, outputPath, i);
        }

        await Task.WhenAll(tasks);
    }

    static async Task GeneratePdfAsync(string htmlContent, string outputPath, int taskId)
    {
        Console.WriteLine($"Task {taskId} is waiting for access...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Task {taskId} has started PDF generation.");
            ChromePdfRenderer renderer = new ChromePdfRenderer();
            PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);
            pdf.SaveAs(outputPath);
            Console.WriteLine($"Task {taskId} has completed PDF generation.");
        }
        finally
        {
            // Ensure semaphore is released to allow other tasks to proceed.
            _semaphore.Release();
            Console.WriteLine($"Task {taskId} has released semaphore.");
        }
    }
}

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(2); // Limit to 2 concurrent threads.

    static async Task Main(string[] args)
    {
        var tasks = new Task[5];

        for (int i = 0; i < tasks.Length; i++)
        {
            string htmlContent = $"<h1>PDF Document {i}</h1><p>This is a sample PDF content for task {i}.</p>";
            string outputPath = $"output_{i}.pdf";

            // Start multiple tasks to demonstrate controlled concurrency.
            tasks[i] = GeneratePdfAsync(htmlContent, outputPath, i);
        }

        await Task.WhenAll(tasks);
    }

    static async Task GeneratePdfAsync(string htmlContent, string outputPath, int taskId)
    {
        Console.WriteLine($"Task {taskId} is waiting for access...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Task {taskId} has started PDF generation.");
            ChromePdfRenderer renderer = new ChromePdfRenderer();
            PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent);
            pdf.SaveAs(outputPath);
            Console.WriteLine($"Task {taskId} has completed PDF generation.");
        }
        finally
        {
            // Ensure semaphore is released to allow other tasks to proceed.
            _semaphore.Release();
            Console.WriteLine($"Task {taskId} has released semaphore.");
        }
    }
}

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

Friend Class Program
	Private Shared _semaphore As New SemaphoreSlim(2) ' Limit to 2 concurrent threads.

	Shared Async Function Main(ByVal args() As String) As Task
		Dim tasks = New Task(4){}

		For i As Integer = 0 To tasks.Length - 1
			Dim htmlContent As String = $"<h1>PDF Document {i}</h1><p>This is a sample PDF content for task {i}.</p>"
			Dim outputPath As String = $"output_{i}.pdf"

			' Start multiple tasks to demonstrate controlled concurrency.
			tasks(i) = GeneratePdfAsync(htmlContent, outputPath, i)
		Next i

		Await Task.WhenAll(tasks)
	End Function

	Private Shared Async Function GeneratePdfAsync(ByVal htmlContent As String, ByVal outputPath As String, ByVal taskId As Integer) As Task
		Console.WriteLine($"Task {taskId} is waiting for access...")

		' Wait to enter the semaphore.
		Await _semaphore.WaitAsync()

		Try
			Console.WriteLine($"Task {taskId} has started PDF generation.")
			Dim renderer As New ChromePdfRenderer()
			Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync(htmlContent)
			pdf.SaveAs(outputPath)
			Console.WriteLine($"Task {taskId} has completed PDF generation.")
		Finally
			' Ensure semaphore is released to allow other tasks to proceed.
			_semaphore.Release()
			Console.WriteLine($"Task {taskId} has released semaphore.")
		End Try
	End Function
End Class

In this example, we first initialized SemaphoreSlim and set the initial and maximum count of SemaphoreSlim to '2', limiting it to two concurrent PDF generations. We then created a task array which is used to control the number of tasks the program has to do, after which we use a for loop to dynamically create PDFs based on the number of tasks within the task array.

The WaitAsync() method is then used to enter the semaphore, and Release() is used in the finally block to ensure that the semaphore is always released even if an exception occurs. The console output logs show when each task begins, finishes, and releases the semaphore, this allows you to track the concurrency behavior.

Output Console

Output PDF Files

Thread safety is crucial when multiple threads interact with shared resources. In PDF manipulation, SemaphoreSlim ensures that only a defined number of threads can modify PDFs concurrently, preventing race conditions and ensuring consistency. In the following code, we are simulating a scenario where we are adding a watermark to multiple PDFs while ensuring only one operation occurs at a time.

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(1);

    static async Task Main(string[] args)
    {
        // Setting array of tasks
        var tasks = new Task[3];

        for (int i = 0; i < tasks.Length; i++)
        {
            string inputPath = $"input_{i}.pdf";  // Input PDF file path
            string outputPath = $"output_{i}.pdf";  // Output PDF file path
            string watermarkText = @"
<img src='https://ironsoftware.com/img/products/ironpdf-logo-text-dotnet.svg'>
<h1>Iron Software</h1>";

            // Start multiple tasks to add watermarks concurrently.
            tasks[i] = AddWatermarkAsync(inputPath, outputPath, watermarkText, i);
        }

        await Task.WhenAll(tasks); // Wait for all tasks to finish.
    }

    static async Task AddWatermarkAsync(string input, string outputPath, string watermark, int taskId)
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} is waiting to add a watermark...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} is adding a watermark.");
            var pdf = PdfDocument.FromFile(input);
            pdf.ApplyWatermark(watermark); // Add watermark
            pdf.SaveAs(outputPath); // Save the modified PDF
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} has completed watermarking.");
        }
        finally
        {
            // Release the semaphore after the task is done.
            _semaphore.Release();
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} has released semaphore.");
        }
    }
}

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(1);

    static async Task Main(string[] args)
    {
        // Setting array of tasks
        var tasks = new Task[3];

        for (int i = 0; i < tasks.Length; i++)
        {
            string inputPath = $"input_{i}.pdf";  // Input PDF file path
            string outputPath = $"output_{i}.pdf";  // Output PDF file path
            string watermarkText = @"
<img src='https://ironsoftware.com/img/products/ironpdf-logo-text-dotnet.svg'>
<h1>Iron Software</h1>";

            // Start multiple tasks to add watermarks concurrently.
            tasks[i] = AddWatermarkAsync(inputPath, outputPath, watermarkText, i);
        }

        await Task.WhenAll(tasks); // Wait for all tasks to finish.
    }

    static async Task AddWatermarkAsync(string input, string outputPath, string watermark, int taskId)
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} is waiting to add a watermark...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} is adding a watermark.");
            var pdf = PdfDocument.FromFile(input);
            pdf.ApplyWatermark(watermark); // Add watermark
            pdf.SaveAs(outputPath); // Save the modified PDF
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} has completed watermarking.");
        }
        finally
        {
            // Release the semaphore after the task is done.
            _semaphore.Release();
            Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} has released semaphore.");
        }
    }
}

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

Friend Class Program
	Private Shared _semaphore As New SemaphoreSlim(1)

	Shared Async Function Main(ByVal args() As String) As Task
		' Setting array of tasks
		Dim tasks = New Task(2){}

		For i As Integer = 0 To tasks.Length - 1
			Dim inputPath As String = $"input_{i}.pdf" ' Input PDF file path
			Dim outputPath As String = $"output_{i}.pdf" ' Output PDF file path
			Dim watermarkText As String = "
<img src='https://ironsoftware.com/img/products/ironpdf-logo-text-dotnet.svg'>
<h1>Iron Software</h1>"

			' Start multiple tasks to add watermarks concurrently.
			tasks(i) = AddWatermarkAsync(inputPath, outputPath, watermarkText, i)
		Next i

		Await Task.WhenAll(tasks) ' Wait for all tasks to finish.
	End Function

	Private Shared Async Function AddWatermarkAsync(ByVal input As String, ByVal outputPath As String, ByVal watermark As String, ByVal taskId As Integer) As Task
		Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} is waiting to add a watermark...")

		' Wait to enter the semaphore.
		Await _semaphore.WaitAsync()

		Try
			Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} is adding a watermark.")
			Dim pdf = PdfDocument.FromFile(input)
			pdf.ApplyWatermark(watermark) ' Add watermark
			pdf.SaveAs(outputPath) ' Save the modified PDF
			Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} has completed watermarking.")
		Finally
			' Release the semaphore after the task is done.
			_semaphore.Release()
			Console.WriteLine($"{DateTime.Now:HH:mm:ss} - Task {taskId} has released semaphore.")
		End Try
	End Function
End Class

By setting the semaphore count to 1 using private static SemaphoreSlim _semaphore = new SemaphoreSlim(1);, we ensure that only one task can manipulate PDFs at a time.

Wynik konsoli

IronPDF excels in handling resource-intensive tasks, such as converting large HTML files to PDFs, and excels at carrying these tasks out in an asynchronous environment. Using SemaphoreSlim to manage these operations ensures that your application remains responsive without losing performance, even under heavy load.

The following example code demonstrates a scenario where we need to limit the number of concurrent large HTML to PDF conversions to avoid overloading system resources.

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    // Limit concurrent large PDF conversions to 2.
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(2);

    static async Task Main(string[] args)
    {
        var tasks = new Task[4];

        for (int i = 0; i < tasks.Length; i++)
        {
            string htmlContent = $"<h1>Large Document {i}</h1><p>Content for a large HTML file {i}.</p>";
            string outputPath = $"large_output_{i}.pdf";

            // Start multiple tasks to convert large HTML files to PDFs.
            tasks[i] = ConvertLargeHtmlAsync(htmlContent, outputPath, i);
        }

        await Task.WhenAll(tasks); // Wait for all tasks to finish.
    }

    // Method to convert large HTML to PDF using SemaphoreSlim to control resource usage.
    public static async Task ConvertLargeHtmlAsync(string htmlContent, string outputPath, int taskId)
    {
        Console.WriteLine($"Task {taskId} is waiting to start conversion...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Task {taskId} is converting large HTML to PDF.");
            var renderer = new ChromePdfRenderer();
            var pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent); // Convert large HTML to PDF
            pdf.SaveAs(outputPath); // Save the PDF file
            Console.WriteLine($"Task {taskId} has completed conversion.");
        }
        finally
        {
            // Ensure the semaphore is released to allow other tasks to proceed.
            _semaphore.Release();
            Console.WriteLine($"Task {taskId} has released semaphore.");
        }
    }
}

using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    // Limit concurrent large PDF conversions to 2.
    private static SemaphoreSlim _semaphore = new SemaphoreSlim(2);

    static async Task Main(string[] args)
    {
        var tasks = new Task[4];

        for (int i = 0; i < tasks.Length; i++)
        {
            string htmlContent = $"<h1>Large Document {i}</h1><p>Content for a large HTML file {i}.</p>";
            string outputPath = $"large_output_{i}.pdf";

            // Start multiple tasks to convert large HTML files to PDFs.
            tasks[i] = ConvertLargeHtmlAsync(htmlContent, outputPath, i);
        }

        await Task.WhenAll(tasks); // Wait for all tasks to finish.
    }

    // Method to convert large HTML to PDF using SemaphoreSlim to control resource usage.
    public static async Task ConvertLargeHtmlAsync(string htmlContent, string outputPath, int taskId)
    {
        Console.WriteLine($"Task {taskId} is waiting to start conversion...");

        // Wait to enter the semaphore.
        await _semaphore.WaitAsync();

        try
        {
            Console.WriteLine($"Task {taskId} is converting large HTML to PDF.");
            var renderer = new ChromePdfRenderer();
            var pdf = await renderer.RenderHtmlAsPdfAsync(htmlContent); // Convert large HTML to PDF
            pdf.SaveAs(outputPath); // Save the PDF file
            Console.WriteLine($"Task {taskId} has completed conversion.");
        }
        finally
        {
            // Ensure the semaphore is released to allow other tasks to proceed.
            _semaphore.Release();
            Console.WriteLine($"Task {taskId} has released semaphore.");
        }
    }
}

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

Friend Class Program
	' Limit concurrent large PDF conversions to 2.
	Private Shared _semaphore As New SemaphoreSlim(2)

	Shared Async Function Main(ByVal args() As String) As Task
		Dim tasks = New Task(3){}

		For i As Integer = 0 To tasks.Length - 1
			Dim htmlContent As String = $"<h1>Large Document {i}</h1><p>Content for a large HTML file {i}.</p>"
			Dim outputPath As String = $"large_output_{i}.pdf"

			' Start multiple tasks to convert large HTML files to PDFs.
			tasks(i) = ConvertLargeHtmlAsync(htmlContent, outputPath, i)
		Next i

		Await Task.WhenAll(tasks) ' Wait for all tasks to finish.
	End Function

	' Method to convert large HTML to PDF using SemaphoreSlim to control resource usage.
	Public Shared Async Function ConvertLargeHtmlAsync(ByVal htmlContent As String, ByVal outputPath As String, ByVal taskId As Integer) As Task
		Console.WriteLine($"Task {taskId} is waiting to start conversion...")

		' Wait to enter the semaphore.
		Await _semaphore.WaitAsync()

		Try
			Console.WriteLine($"Task {taskId} is converting large HTML to PDF.")
			Dim renderer = New ChromePdfRenderer()
			Dim pdf = Await renderer.RenderHtmlAsPdfAsync(htmlContent) ' Convert large HTML to PDF
			pdf.SaveAs(outputPath) ' Save the PDF file
			Console.WriteLine($"Task {taskId} has completed conversion.")
		Finally
			' Ensure the semaphore is released to allow other tasks to proceed.
			_semaphore.Release()
			Console.WriteLine($"Task {taskId} has released semaphore.")
		End Try
	End Function
End Class

When dealing with resource-heavy tasks like converting large HTML files to PDFs, SemaphoreSlim can help balance the load and optimize resource usage. By setting a limit of 2 concurrent operations, we prevent the system from being overwhelmed by resource-intensive PDF generation tasks. This approach helps distribute the workload more evenly, improving overall application performance and stability.

Output image: Files generated with this method

IronPDF is designed to handle concurrent PDF processing tasks efficiently, offering performance and reliability superior to many other PDF libraries. Its robust architecture allows it to scale with your application's needs, making it ideal for high-demand environments. When compared to other PDF libraries based on performance, ease-of-use, and robustness criteria, IronPDF proves to be a strong competitor. To showcase this, I have compared IronPDF to several other popular PDF libraries such as iTextSharp, PDFsharp, DinkToPdf, and EvoPDF:

1. Performance

IronPDF:

• Rendering Speed: IronPDF is known for its fast and efficient rendering capabilities, particularly when converting HTML to PDF. It uses Chrome-based rendering, which provides high fidelity to the original HTML content, including CSS and JavaScript execution.
• Resource Management: IronPDF is optimized for handling large and complex PDFs with less memory usage compared to other libraries, making it suitable for high-volume applications.
• Asynchronous Operations: Supports asynchronous PDF generation, allowing for better performance in web applications where responsiveness is crucial.

iTextSharp:

• Rendering Speed: iTextSharp offers good performance for text-heavy PDFs but can slow down significantly with complex layouts or images.
• Resource Management: Memory usage can be higher with iTextSharp, especially when handling large documents or complex manipulations, leading to performance bottlenecks in some cases.

PDFsharp:

• Rendering Speed: PDFsharp is generally slower compared to IronPDF when dealing with complex layouts or when converting from HTML, as it lacks a native HTML rendering engine.
• Resource Management: It is less optimized for memory usage and can struggle with large files or documents that contain numerous images.

DinkToPdf:

• Szybkość renderowania: DinkToPdf wykorzystuje silnik wkhtmltopdf, który sprawdza się w przypadku podstawowej konwersji HTML do PDF, ale może mieć trudności z bardziej złożoną lub dynamiczną treścią.
• Zarządzanie zasobami: Często wymaga znacznej ilości pamięci i mocy obliczeniowej, a także nie posiada natywnej obsługi operacji asynchronicznych, co ogranicza jego wydajność w scenariuszach o dużym obciążeniu.

EvoPDF:

• Szybkość renderowania: EvoPDF, podobnie jak IronPDF, oferuje renderowanie oparte na przeglądarce Chrome, zapewniając dobrą wydajność, zwłaszcza w przypadku konwersji HTML do PDF.
• Zarządzanie zasobami: Jest dobrze zoptymalizowane, ale w niektórych scenariuszach może nadal zużywać więcej zasobów w porównaniu z IronPDF ze względu na mniej agresywne optymalizacje.

2. Łatwość użytkowania

IronPDF:

• Projekt API: IronPDF oferuje nowoczesne, intuicyjne API, które jest łatwe w użyciu dla programistów na każdym poziomie zaawansowania. Biblioteka została zaprojektowana tak, aby płynnie współpracować z aplikacjami .NET, co czyni ją doskonałym wyborem dla programistów C#.
• Dokumentacja i wsparcie: Kompleksowa dokumentacja, duża liczba przykładów kodu oraz doskonała obsługa klienta ułatwiają rozpoczęcie pracy i szybkie rozwiązywanie problemów.
• Instalacja i integracja: Łatwa instalacja za pośrednictwem NuGet i płynna integracja z istniejącymi projektami .NET, wymagająca minimalnej konfiguracji.

iTextSharp:

• Projekt API: iTextSharp charakteryzuje się stromą krzywą uczenia się, a jego bardziej złożone API może być przytłaczające dla początkujących. Jego elastyczność odbywa się kosztem prostoty.
• Dokumentacja i wsparcie: Chociaż oprogramowanie jest dobrze udokumentówane, rozbudowane opcje konfiguracyjne mogą utrudniać znalezienie prostych przykładów dotyczących typowych zadań.
• Instalacja i integracja: Dostępne za pośrednictwem NuGet, ale skuteczna integracja wymaga głębszego zrozumienia API.

PDFsharp:

• Projekt API: PDFsharp został zaprojektowany z myślą o prostych, podstawowych zadaniach związanych z plikami PDF, ale nie posiada wbudowanych zaawansowanych funkcji, co może ograniczać jego zastosowanie w bardziej złożonych scenariuszach.
• Dokumentacja i wsparcie: Dostępna jest podstawowa dokumentacja, ale jest ona mniej obszerna i brakuje w niej szczegółowych przykładów zaawansowanego użytkowania w porównaniu z IronPDF.
• Instalacja i integracja: Łatwa instalacja za pośrednictwem NuGet, ale oferuje ograniczoną funkcjonalność konwersji HTML do PDF.

DinkToPdf:

• Projekt API: API DinkToPdf jest stosunkowo proste, ale mniej dopracowane w porównaniu z IronPDF. Narzędzie to służy głównie do konwersji HTML na PDF i oferuje mniej funkcji do bezpośredniej edycji plików PDF.
• Dokumentacja i wsparcie: Dokumentacja jest ograniczona, a wsparcie społeczności nie jest tak rozbudowane jak w przypadku innych bibliotek, co utrudnia rozwiązywanie problemów.
• Instalacja i integracja: Instalacja może być bardziej złożona i wymagać dodatkowych zależności, takich jak wkhtmltopdf, co może skomplikówać konfigurację.

EvoPDF:

• Projekt API: EvoPDF oferuje proste API podobne do IronPDF, skoncentrowane głównie na konwersji HTML do PDF z myślą o łatwości użytkowania.
• Dokumentacja i wsparcie: Dobrze udokumentówane z dobrymi opcjami wsparcia, ale nie tak bogate w przykłady tworzone przez społeczność jak IronPDF.
• Instalacja i integracja: Łatwa integracja z projektami .NET dzięki dostępnym pakietom NuGet.

3. Solidność

IronPDF:

• Zestaw funkcji: IronPDF jest niezwykle niezawodny i obsługuje szeroki zakres funkcji, w tym konwersję HTML do PDF, edycję plików PDF, wyodrębnianie tekstu, szyfrowanie, adnotacje i podpisy cyfrowe.
• Obsługa błędów: Oferuje solidną obsługę błędów i zarządzanie wyjątkami, dzięki czemu jest niezawodna w środowiskach produkcyjnych.
• Kompatybilność: W pełni kompatybilny z .NET Core, .NET 5+ oraz starszymi wersjami .NET Framework, co sprawia, że jest wszechstronny w różnych typach projektów.

iTextSharp:

• Zestaw funkcji: iTextSharp jest niezwykle solidnym narzędziem z kompleksowym zestawem funkcji, które obsługują niemal każde zadanie związane z plikami PDF, w tym złożone operacje i obsługę formularzy.
• Obsługa błędów: Dobra obsługa błędów, ale zarządzanie nią może być skomplikowane ze względu na złożoność biblioteki.
• Kompatybilność: Doskonale nadaje się do szerokiego zakresu środowisk, w tym .NET Framework i .NET Core.

PDFsharp:

• Zestaw funkcji: Podstawowe funkcje tworzenia i edycji plików PDF. Brakuje niektórych zaawansowanych funkcji, takich jak konwersja HTML do PDF i bardziej zaawansowana edycja dokumentów.
• Obsługa błędów: Podstawowa obsługa błędów; jest mniej niezawodny w złożonych scenariuszach w porównaniu z bardziej rozbudowanymi bibliotekami, takimi jak IronPDF.
• Kompatybilność: Kompatybilny z .NET Framework i .NET Core, ale z ograniczoną funkcjonalnością zaawansowaną.

DinkToPdf:

• Zestaw funkcji: Skupia się głównie na konwersji HTML do PDF. Ograniczone możliwości bezpośredniej edycji plików PDF oraz brak zaawansowanych funkcji, takich jak adnotacje i obsługa formularzy.
• Obsługa błędów: Podstawowa obsługa błędów; podatne na awarie lub zawieszanie się w przypadku złożonego kodu HTML lub dużych plików.
• Kompatybilność: Działa z .NET Core i .NET Framework, ale wymaga zewnętrznych zależności, co może powodować problemy z kompatybilnością.

EvoPDF:

• Zestaw funkcji: Oferuje rozbudowany zestaw funkcji podobnych do IronPDF, w tym zaawansowaną konwersję HTML do PDF oraz pewne możliwości edycji dokumentów.
• Obsługa błędów: Solidna obsługa błędów i niezawodna wydajność w środowiskach produkcyjnych.
• Kompatybilność: W pełni kompatybilny z .NET Core, .NET Framework i nowszymi wersjami .NET, co czyni go wszechstronnym i niezawodnym.

Podsumowanie

• Wydajność: IronPDF i EvoPDF przodują pod względem wydajności dzięki silnikom renderującym opartym na przeglądarce Chrome, podczas gdy iTextSharp i PDFsharp mogą pozostawać w tyle przy obsłudze złożonych dokumentów.
• Łatwość użytkowania: IronPDF wyróżnia się intuicyjnym interfejsem API i obszerną dokumentacją, dzięki czemu jest dostępny dla programistów na każdym poziomie zaawansowania. iTextSharp oferuje dużą moc kosztem prostoty, podczas gdy DinkToPdf i PDFsharp są łatwiejsze w użyciu, ale mają mniej funkcji.
• Solidność: IronPDF i iTextSharp oferują najbardziej rozbudowane zestawy funkcji, przy czym IronPDF zapewnia prostszą integrację i nowoczesne funkcje, takie jak obsługa asynchroniczna, podczas gdy iTextSharp obejmuje bardziej niszowe przypadki użycia i wymaga dłuższego okresu nauki obsługi.