O gerenciamento de concorrência é um aspecto crítico de aplicações de alto desempenho em C#. Isso garante que os recursos sejam utilizados de forma eficiente, evitando possíveis conflitos ou gargalos de desempenho; portanto, ter um controle de acesso baseado em semáforos, embora leve, pode ser muito útil. É aí que o SemaphoreSlim entra em ação. SemaphoreSlim é uma primitiva de sincronização leve que controla o acesso a recursos, prevenindo condições de corrida e garantindo a segurança de threads.
E se você quisesse implementar isso juntamente com uma biblioteca de PDF para gerenciar os processos de geração de PDFs? Você pode estar procurando por uma biblioteca de PDFs poderosa, e é aí que o IronPDF entra em cena. IronPDF é uma biblioteca robusta para geração e manipulação de PDFs, destinada a desenvolvedores .NET , que pode se beneficiar muito do gerenciamento de concorrência quando usada em ambientes multithread.
Se você quiser ver o SemaphoreSlim e o IronPDF em ação, continue lendo, pois exploraremos os benefícios de usar o SemaphoreSlim e como integrá-lo ao IronPDF para lidar com segurança com operações simultâneas, melhorar o desempenho e garantir o processamento confiável de PDFs.
SemaphoreSlim é uma primitiva de sincronização no .NET que limita o número de threads que podem acessar um recurso específico ou um conjunto de recursos simultaneamente. Trata-se de uma versão simplificada da classe Semaphore completa, projetada para funcionar de forma mais eficiente em situações onde um semáforo mais simples e rápido é suficiente.
Algumas vantagens de usar o SemaphoreSlim são a redução da sobrecarga do sistema em comparação com o Semaphore, sua capacidade de gerenciar recursos limitados (como conexões de banco de dados ou acesso a arquivos) e o suporte a métodos de espera assíncrona, o que o torna adequado para padrões de programação assíncrona/await modernos.
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
Module Program
' Semaphore count
Private _semaphore As New SemaphoreSlim(3) ' Limit to 3 concurrent threads.
Async Function Main(args As String()) As Task
' Start tasks that will wait on the semaphore.
Dim tasks(4) As Task
For i As Integer = 0 To tasks.Length - 1
tasks(i) = Task.Run(Function() AccessResource(i))
Next
' 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
Async Function AccessResource(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 ModuleDurante a execução de um programa, a contagem de semáforos pode atingir dinamicamente zero threads quando todas as permissões disponíveis tiverem sido adquiridas pelas threads. Este estado indica que o número máximo de acessos simultâneos permitidos foi atingido.
Se desejar, você pode definir o número inicial e máximo de threads, começando com a contagem inicial de semáforos em zero e, em seguida, usando uma tarefa de inicialização separada que incrementa a contagem de semáforos quando o recurso estiver pronto, permitindo que o número de threads escolhido prossiga. Quando a contagem de semáforos é zero, os threads aguardam ao tentar entrar no semáforo; isso é chamado de "espera de bloco".
Você pode monitorar a contagem anterior do semáforo para ajustar o comportamento do semáforo com base nessa contagem. Em seguida, você pode manipular o semáforo de acordo com a sua necessidade (por exemplo, liberando ou aguardando). À medida que os fios se soltam, a contagem de semáforos diminui.
Alguns casos de uso comuns para o SemaphoreSlim são:
Para começar a usar o IronPDF em um ambiente multithread, instale o pacote NuGet do IronPDF . Você pode fazer isso navegando até Ferramentas > Gerenciador de Pacotes NuGet > Gerenciador de Pacotes NuGet para a Solução e pesquisando por IronPDF:
Ou, alternativamente, execute o seguinte comando no Console do Gerenciador de Pacotes:
Para começar a usar o IronPDF no seu código, certifique-se de ter colocado a declaração using IronPdf no topo do seu arquivo de código. Para um guia mais detalhado sobre como configurar o IronPDF no seu ambiente, confira sua página de introdução.
Ao usar o SemaphoreSlim, você pode controlar efetivamente o acesso às tarefas de geração de PDFs. Isso garante que seu aplicativo não tente gerar muitos PDFs simultaneamente, o que poderia afetar o desempenho ou causar falhas.
O código de exemplo a seguir demonstra o uso básico do SemaphoreSlim com o 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.");
}
}
}Imports IronPdf
Imports System
Imports System.Threading
Imports System.Threading.Tasks
Module Program
Private _semaphore As New SemaphoreSlim(2) ' Limit to 2 concurrent threads.
Sub Main(args As String())
Dim tasks(4) As Task
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
Task.WhenAll(tasks).Wait()
End Sub
Private Async Function GeneratePdfAsync(htmlContent As String, outputPath As String, 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 ModuleNeste exemplo, primeiro inicializamos o SemaphoreSlim e definimos a contagem inicial e máxima do SemaphoreSlim como '2', limitando-o a duas gerações simultâneas de PDF. Em seguida, criamos uma matriz de tarefas que é usada para controlar o número de tarefas que o programa deve executar. Depois disso, usamos um loop "for" para criar PDFs dinamicamente com base no número de tarefas dentro da matriz de tarefas.
O método WaitAsync() é então usado para entrar no semáforo, e Release() é usado no bloco finally para garantir que o semáforo seja sempre liberado mesmo que ocorra uma exceção. Os registros de saída do console mostram quando cada tarefa começa, termina e libera o semáforo, permitindo rastrear o comportamento da concorrência.
A segurança de threads é crucial quando várias threads interagem com recursos compartilhados. Na manipulação de PDFs, o SemaphoreSlim garante que apenas um número definido de threads possa modificar PDFs simultaneamente, evitando condições de corrida e assegurando a consistência. No código a seguir, estamos simulando um cenário em que adicionamos uma marca d'água a vários PDFs, garantindo que apenas uma operação ocorra por vez.
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
Module Program
Private _semaphore As New SemaphoreSlim(1)
Async Function Main(args As String()) As Task
' Setting array of tasks
Dim tasks(2) As Task
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
Await Task.WhenAll(tasks) ' Wait for all tasks to finish.
End Function
Async Function AddWatermarkAsync(input As String, outputPath As String, watermark As String, 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 ModuleAo definir a contagem do semáforo para 1 usando private static SemaphoreSlim _semaphore = new SemaphoreSlim(1);, garantimos que apenas uma tarefa possa manipular PDFs por vez.
O IronPDF se destaca no processamento de tarefas que exigem muitos recursos, como a conversão de arquivos HTML grandes em PDFs, e é excelente para executar essas tarefas em um ambiente assíncrono. Utilizar o SemaphoreSlim para gerenciar essas operações garante que seu aplicativo permaneça responsivo sem perda de desempenho, mesmo sob carga pesada.
O código de exemplo a seguir demonstra um cenário em que precisamos limitar o número de conversões simultâneas de arquivos HTML grandes para PDF, a fim de evitar a sobrecarga dos recursos do sistema.
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
Module Program
' Limit concurrent large PDF conversions to 2.
Private _semaphore As New SemaphoreSlim(2)
Async Function Main(args As String()) As Task
Dim tasks(3) As Task
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
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 Async Function ConvertLargeHtmlAsync(htmlContent As String, outputPath As String, 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 As 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 ModuleAo lidar com tarefas que consomem muitos recursos, como a conversão de arquivos HTML grandes em PDFs, o SemaphoreSlim pode ajudar a equilibrar a carga e otimizar o uso de recursos. Ao definir um limite de 2 operações simultâneas, evitamos que o sistema seja sobrecarregado por tarefas de geração de PDF que consomem muitos recursos. Essa abordagem ajuda a distribuir a carga de trabalho de forma mais uniforme, melhorando o desempenho e a estabilidade geral do aplicativo.
Podem ocorrer impasses se os semáforos não forem liberados corretamente. Uma boa prática a ter em mente é o uso de blocos try-finally para garantir que os semáforos sejam liberados mesmo que ocorra uma exceção, evitando impasses e mantendo sua aplicação funcionando sem problemas. Algumas melhores práticas a serem lembradas para evitar bloqueios incluem sempre liberar o semáforo no bloco finally e evitar usar chamadas bloqueantes como Wait() e Result dentro do seu código assíncrono.
using IronPdf;
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
private static SemaphoreSlim _semaphore = new SemaphoreSlim(3);
static async Task Main(string[] args)
{
var tasks = new Task[3];
for (int i = 0; i < tasks.Length; i++)
{
string content = $"<h1>Document {i}</h1><p>Content for PDF {i}.</p>";
string path = $"safe_output_{i}.pdf";
// Start multiple tasks to demonstrate deadlock-free semaphore usage.
tasks[i] = SafePdfTaskAsync(content, path, i);
}
await Task.WhenAll(tasks); // Wait for all tasks to finish.
}
// Method demonstrating best practices for using SemaphoreSlim to avoid deadlocks.
public static async Task SafePdfTaskAsync(string content, string path, int taskId)
{
Console.WriteLine($"Task {taskId} is waiting to generate PDF...");
// Wait to enter the semaphore.
await _semaphore.WaitAsync();
try
{
Console.WriteLine($"Task {taskId} is generating PDF.");
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync(content); // Render HTML to PDF
pdf.SaveAs(path); // Save the PDF
Console.WriteLine($"Task {taskId} has completed PDF generation.");
}
catch (Exception ex)
{
Console.WriteLine($"Task {taskId} encountered an error: {ex.Message}");
}
finally
{
// Always release the semaphore, even if an error occurs.
_semaphore.Release();
Console.WriteLine($"Task {taskId} has released semaphore.");
}
}
}Imports IronPdf
Imports System
Imports System.Threading
Imports System.Threading.Tasks
Module Program
Private _semaphore As New SemaphoreSlim(3)
Sub Main(args As String())
Dim tasks(2) As Task
For i As Integer = 0 To tasks.Length - 1
Dim content As String = $"<h1>Document {i}</h1><p>Content for PDF {i}.</p>"
Dim path As String = $"safe_output_{i}.pdf"
' Start multiple tasks to demonstrate deadlock-free semaphore usage.
tasks(i) = SafePdfTaskAsync(content, path, i)
Next
Task.WhenAll(tasks).Wait() ' Wait for all tasks to finish.
End Sub
' Method demonstrating best practices for using SemaphoreSlim to avoid deadlocks.
Public Async Function SafePdfTaskAsync(content As String, path As String, taskId As Integer) As Task
Console.WriteLine($"Task {taskId} is waiting to generate PDF...")
' Wait to enter the semaphore.
Await _semaphore.WaitAsync()
Try
Console.WriteLine($"Task {taskId} is generating PDF.")
Dim renderer As New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync(content) ' Render HTML to PDF
pdf.SaveAs(path) ' Save the PDF
Console.WriteLine($"Task {taskId} has completed PDF generation.")
Catch ex As Exception
Console.WriteLine($"Task {taskId} encountered an error: {ex.Message}")
Finally
' Always release the semaphore, even if an error occurs.
_semaphore.Release()
Console.WriteLine($"Task {taskId} has released semaphore.")
End Try
End Function
End ModuleUsando um bloco try-catch-finally, garantimos que o objeto SemaphoreSlim seja sempre liberado, mesmo que uma exceção seja lançada, assim prevenindo bloqueios. Ao registrar erros e gerenciar adequadamente as liberações de semáforos, podemos manter o programa estável e evitar qualquer comportamento inesperado.
Como você pode ver na imagem de saída abaixo, simulei um erro tentando fazer o programa carregar um arquivo HTML que não existe, mas mesmo com esse erro, o programa imprime a mensagem de erro que me informa o que deu errado e, em seguida, libera o semáforo usando o bloco finally.
O IronPDF foi projetado para lidar com tarefas simultâneas de processamento de PDF de forma eficiente, oferecendo desempenho e confiabilidade superiores a muitas outras bibliotecas de PDF. Sua arquitetura robusta permite que ele se adapte às necessidades da sua aplicação, tornando-o ideal para ambientes de alta demanda. Quando comparado a outras bibliotecas de PDF com base em critérios de desempenho, facilidade de uso e robustez, o IronPDF demonstra ser um forte concorrente. Para mostrar isso, comparei o IronPDF com várias outras bibliotecas de PDF populares, como iText, PDFSharp, DinkToPdf e EvoPDF:
IronPDF:
iText:
PDFSharp:
DinkToPdf:
EvoPDF:
IronPDF:
iText:
PDFSharp:
DinkToPdf:
EvoPDF:
IronPDF:
iText:
PDFSharp:
DinkToPdf:
EvoPDF:
O IronPDF integra-se perfeitamente com modelos de programação assíncrona , complementando mecanismos de controle de concorrência como o SemaphoreSlim. Isso permite que os desenvolvedores criem aplicativos responsivos e com bom desempenho com o mínimo de esforço.
O IronPDF também oferece ampla documentação e recursos de suporte que ajudam os desenvolvedores a entender e implementar práticas eficazes de tratamento de erros. Esse suporte abrangente é valioso para solucionar problemas e otimizar operações de PDF em projetos .NET .
IronPDF oferece:
Para obter mais informações, consulte a extensa documentação do IronPDF.
Utilizar o SemaphoreSlim para gerenciamento de concorrência em aplicações .NET é crucial, especialmente ao lidar com tarefas que consomem muitos recursos, como o processamento de PDFs. Ao integrar o SemaphoreSlim com o IronPDF, os desenvolvedores podem obter um controle de concorrência seguro, eficiente e confiável, garantindo que seus aplicativos permaneçam responsivos e com bom desempenho.
Descubra como o IronPDF pode otimizar seus fluxos de trabalho de processamento de PDFs. Experimente por si mesmo com sua avaliação gratuita começando a partir de apenas $999 se quiser manter essa poderosa ferramenta em seus projetos.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
