Ao trabalhar com aplicações modernas, desenvolvedores .NET como você podem precisar criar um serviço centralizado de geração de PDFs. Seja para gerar faturas, relatórios, certificados ou contratos, ter uma API .NET dedicada para PDFs pode ser muito útil para gerenciar arquivos PDF com eficiência. Então, como isso pode melhorar suas tarefas de geração de PDFs? Isso é feito ao proporcionar consistência, facilidade de manutenção e escalabilidade em seus aplicativos para desktop e web. Nunca foi tão fácil gerenciar o conteúdo de documentos, páginas de PDF e campos de formulário em PDF.
Neste tutorial, você aprenderá como criar uma API de PDF pronta para produção usando ASP.NET Core e IronPDF , uma poderosa biblioteca de PDF for .NET . Criaremos endpoints RESTful capazes de gerar PDFs a partir de HTML, mesclar documentos, adicionar marcas d'água e lidar com diversos cenários reais de geração de PDFs em sua API Web.
Antes de analisarmos o código, vamos entender por que criar uma API dedicada para PDFs faz sentido:
Pronto para começar a construir? Baixe a versão de avaliação gratuita do IronPDF e siga este tutorial para criar arquivos PDF programaticamente em seus projetos .NET Framework .
O IronPDF se destaca como a principal biblioteca de PDF para desenvolvedores .NET , oferecendo um conjunto abrangente de recursos que tornam a geração de PDFs em projetos de API Web simples e confiável. Ele é baseado em um mecanismo de renderização do Chrome, que garante conversões de HTML para PDF com perfeição de pixels, muitas vezes com apenas algumas linhas de código. Ele faz tudo isso mantendo o estilo, a execução do JavaScript e os layouts responsivos.
Principais funcionalidades que tornam o IronPDF ideal para o desenvolvimento de APIs PDF em .NET :
Vamos começar criando um novo projeto de API Web ASP.NET Core e instalando os pacotes necessários.
Primeiro, vamos criar o projeto no qual construiremos nossa ferramenta de geração de PDF.
dotnet new webapi -n PdfApiService
cd PdfApiServiceO próximo passo é adicionar o IronPDF ao seu projeto via NuGet:
dotnet add package IronPdfOu, utilizando o Console do Gerenciador de Pacotes NuGet no Visual Studio:
Um aspecto essencial do desenvolvimento em C# é manter uma pasta de projeto limpa e bem estruturada. Por exemplo:
Vamos criar um endpoint simples que converta HTML para o formato PDF. Primeiro, crie a interface de serviço e a implementação:
Primeiro, adicionaremos o seguinte ao nosso arquivo IPdfService.cs:
public interface IPdfService
{
byte[] GeneratePdfFromHtml(string htmlContent);
byte[] GeneratePdfFromUrl(string url);
}Public Interface IPdfService
Function GeneratePdfFromHtml(htmlContent As String) As Byte()
Function GeneratePdfFromUrl(url As String) As Byte()
End InterfaceNo arquivo PdfService.cs, adicionaremos o seguinte:
using IronPdf;
public class PdfService : IPdfService
{
private readonly ChromePdfRenderer _renderer;
public PdfService()
{
_renderer = new ChromePdfRenderer();
// Configure rendering options for optimal PDF generation in .NET
_renderer.RenderingOptions.MarginTop = 20;
_renderer.RenderingOptions.MarginBottom = 20;
_renderer.RenderingOptions.PrintHtmlBackgrounds = true;
}
public byte[] GeneratePdfFromHtml(string htmlContent)
{
// Generate PDF from HTML using the .NET PDF API
var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
return pdf.BinaryData;
}
public byte[] GeneratePdfFromUrl(string url)
{
// Convert URL to PDF in the REST API
var pdf = _renderer.RenderUrlAsPdf(url);
return pdf.BinaryData;
}
}Imports IronPdf
Public Class PdfService
Implements IPdfService
Private ReadOnly _renderer As ChromePdfRenderer
Public Sub New()
_renderer = New ChromePdfRenderer()
' Configure rendering options for optimal PDF generation in .NET
_renderer.RenderingOptions.MarginTop = 20
_renderer.RenderingOptions.MarginBottom = 20
_renderer.RenderingOptions.PrintHtmlBackgrounds = True
End Sub
Public Function GeneratePdfFromHtml(htmlContent As String) As Byte()
' Generate PDF from HTML using the .NET PDF API
Dim pdf = _renderer.RenderHtmlAsPdf(htmlContent)
Return pdf.BinaryData
End Function
Public Function GeneratePdfFromUrl(url As String) As Byte()
' Convert URL to PDF in the REST API
Dim pdf = _renderer.RenderUrlAsPdf(url)
Return pdf.BinaryData
End Function
End ClassO PdfService lida com o processo principal de conversão de HTML em PDF. Utilizando o ChromePdfRenderer do IronPDF, esta classe é configurada com valores padrão adequados, como margens de página e renderização de fundo, para produzir um documento final refinado.
Quando o controlador envia HTML bruto, o serviço usa o IronPDF para renderizá-lo em um PDF de qualidade profissional e retorna o resultado como dados em bytes, prontos para download. Além disso, também pode lidar com páginas da web inteiras, convertendo um URL diretamente em PDF.
Agora é hora de criar o controlador para nossa API. Isso fornecerá um endpoint de API capaz de gerar arquivos PDF a partir de HTML. Em seguida, será possível baixar e salvar documentos PDF em seu sistema para uso posterior ou compartilhamento.
// Controllers/PdfController.cs
using Microsoft.AspNetCore.Mvc;
[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
private readonly IPdfService _pdfService;
public PdfController(IPdfService pdfService)
{
_pdfService = pdfService;
}
[HttpPost("html-to-pdf")]
public IActionResult ConvertHtmlToPdf([FromBody] HtmlRequest request)
{
try
{
var pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent);
// Return as downloadable file
return File(pdfBytes, "application/pdf", "document.pdf");
}
catch (Exception ex)
{
return BadRequest($"Error generating PDF: {ex.Message}");
}
}
}Imports Microsoft.AspNetCore.Mvc
<ApiController>
<Route("api/[controller]")>
Public Class PdfController
Inherits ControllerBase
Private ReadOnly _pdfService As IPdfService
Public Sub New(pdfService As IPdfService)
_pdfService = pdfService
End Sub
<HttpPost("html-to-pdf")>
Public Function ConvertHtmlToPdf(<FromBody> request As HtmlRequest) As IActionResult
Try
Dim pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent)
' Return as downloadable file
Return File(pdfBytes, "application/pdf", "document.pdf")
Catch ex As Exception
Return BadRequest($"Error generating PDF: {ex.Message}")
End Try
End Function
End ClassEm seguida, no arquivo HtmlRequest.cs, adicionaremos o seguinte:
// Models/HtmlRequest.cs
public class HtmlRequest
{
public string HtmlContent { get; set; }
public string FileName { get; set; } = "document.pdf";
}' Models/HtmlRequest.vb
Public Class HtmlRequest
Public Property HtmlContent As String
Public Property FileName As String = "document.pdf"
End ClassNo primeiro arquivo, configuramos um endpoint de API simples que transforma HTML em um PDF para download. Quando alguém envia conteúdo HTML para a rota api/pdf/html-to-pdf com uma simples requisição POST, o PdfController delega a tarefa de convertê-lo em PDF para um serviço dedicado.
Após a criação do PDF, o controlador o devolve ao usuário como um arquivo pronto para download. A própria requisição é estruturada usando o modelo HtmlRequest, que carrega tanto o HTML bruto quanto um nome de arquivo opcional para o documento final. Resumindo, essa configuração facilita para os clientes o envio de HTML e o recebimento instantâneo de um PDF finalizado.
Atualize seu arquivo Program.cs para registrar o serviço de PDF:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
// Register PDF service
builder.Services.AddSingleton<IPdfService, PdfService>();
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.MapControllers();
app.Run();Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection
Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllers()
builder.Services.AddEndpointsApiExplorer()
builder.Services.AddSwaggerGen()
' Register PDF service
builder.Services.AddSingleton(Of IPdfService, PdfService)()
Dim app = builder.Build()
If app.Environment.IsDevelopment() Then
app.UseSwagger()
app.UseSwaggerUI()
End If
app.UseHttpsRedirection()
app.MapControllers()
app.Run()Sua API deve suportar diferentes maneiras de retornar PDFs com base nas necessidades do cliente:
[HttpPost("generate")]
public IActionResult GeneratePdf([FromBody] PdfRequest request)
{
var pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent);
switch (request.ResponseType?.ToLower())
{
case "base64":
return Ok(new
{
data = Convert.ToBase64String(pdfBytes),
filename = request.FileName
});
case "inline":
return File(pdfBytes, "application/pdf");
default: // download
return File(pdfBytes, "application/pdf", request.FileName);
}
}Imports Microsoft.AspNetCore.Mvc
<HttpPost("generate")>
Public Function GeneratePdf(<FromBody> request As PdfRequest) As IActionResult
Dim pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent)
Select Case request.ResponseType?.ToLower()
Case "base64"
Return Ok(New With {
.data = Convert.ToBase64String(pdfBytes),
.filename = request.FileName
})
Case "inline"
Return File(pdfBytes, "application/pdf")
Case Else ' download
Return File(pdfBytes, "application/pdf", request.FileName)
End Select
End FunctionAqui, adicionamos um endpoint de geração de PDF mais flexível ao controlador. Em vez de sempre forçar o download de um arquivo, o método GeneratePdf permite que o cliente escolha como deseja que o resultado seja retornado. Essa opção oferece flexibilidade, permitindo que os PDFs sejam exibidos em vários formatos: como um arquivo para download, diretamente no navegador ou codificados como uma string Base64 para facilitar o uso em APIs.
A solicitação é definida pelo modelo PdfRequest, que se baseia no modelo HtmlRequest anterior e adiciona uma opção ResponseType. Resumindo, isso dá aos usuários mais controle sobre como recebem seus PDFs, tornando a API mais versátil e fácil de usar.
Agora, quando executarmos nosso programa, veremos essa saída no Swagger.
Vamos expandir nosso serviço para lidar com diversos cenários de geração de PDFs:
[HttpPost("url-to-pdf")]
public async Task<IActionResult> ConvertUrlToPdf([FromBody] UrlRequest request)
{
try
{
var pdfBytes = await Task.Run(() =>
_pdfService.GeneratePdfFromUrl(request.Url));
return File(pdfBytes, "application/pdf",
$"{request.FileName ?? "website"}.pdf");
}
catch (Exception ex)
{
return BadRequest($"Failed to convert URL: {ex.Message}");
}
}
public class UrlRequest
{
public string Url { get; set; }
public string FileName { get; set; }
}Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
<HttpPost("url-to-pdf")>
Public Async Function ConvertUrlToPdf(<FromBody> request As UrlRequest) As Task(Of IActionResult)
Try
Dim pdfBytes = Await Task.Run(Function() _pdfService.GeneratePdfFromUrl(request.Url))
Return File(pdfBytes, "application/pdf", $"{If(request.FileName, "website")}.pdf")
Catch ex As Exception
Return BadRequest($"Failed to convert URL: {ex.Message}")
End Try
End Function
Public Class UrlRequest
Public Property Url As String
Public Property FileName As String
End ClassEste endpoint permite que os clientes enviem um URL e recebam de volta um PDF da página web pronto para download. Quando uma solicitação POST para /api/pdf/url-to-pdf é recebida, o controlador usa o _pdfService para converter a URL fornecida em bytes PDF em segundo plano e, em seguida, os retorna como um arquivo para download. Se algo der errado durante a conversão, o programa responde de forma adequada com uma mensagem de erro clara.
Vamos tentar usar a URL "https://www.apple.com/nz "e teste a solicitação POST. Abaixo está a saída que obtivemos."
public byte[] AddWatermarkFromFile(string filePath, string watermarkText)
{
// Load PDF directly from file
var pdf = PdfDocument.FromFile(filePath);
pdf.ApplyWatermark(
$"<h1 style='color:red;font-size:72px;'>{watermarkText}</h1>",
75,
IronPdf.Editing.VerticalAlignment.Middle,
IronPdf.Editing.HorizontalAlignment.Center
);
return pdf.BinaryData;
}Imports IronPdf
Public Function AddWatermarkFromFile(filePath As String, watermarkText As String) As Byte()
' Load PDF directly from file
Dim pdf = PdfDocument.FromFile(filePath)
pdf.ApplyWatermark(
$"<h1 style='color:red;font-size:72px;'>{watermarkText}</h1>",
75,
IronPdf.Editing.VerticalAlignment.Middle,
IronPdf.Editing.HorizontalAlignment.Center
)
Return pdf.BinaryData
End FunctionAqui, estamos apenas carregando manualmente um arquivo local para fins de teste. No entanto, você pode ajustar isso para que sua API de PDF gere um documento PDF e, em seguida, aplicar uma marca d'água personalizada com facilidade.
Para aplicações práticas, você frequentemente precisará gerar PDFs a partir de modelos com dados dinâmicos:
[HttpPost("from-template")]
public IActionResult GenerateFromTemplate([FromBody] TemplateRequest request)
{
// Simple template replacement
var html = request.Template;
foreach (var item in request.Data)
{
html = html.Replace($"{{{{{item.Key}}}}}", item.Value);
}
var pdfBytes = _pdfService.GeneratePdfFromHtml(html);
return File(pdfBytes, "application/pdf", request.FileName);
}
public class TemplateRequest
{
public string Template { get; set; }
public Dictionary<string, string> Data { get; set; }
public string FileName { get; set; } = "document.pdf";
}Imports Microsoft.AspNetCore.Mvc
<HttpPost("from-template")>
Public Function GenerateFromTemplate(<FromBody> request As TemplateRequest) As IActionResult
' Simple template replacement
Dim html As String = request.Template
For Each item In request.Data
html = html.Replace($"{{{{{item.Key}}}}}", item.Value)
Next
Dim pdfBytes As Byte() = _pdfService.GeneratePdfFromHtml(html)
Return File(pdfBytes, "application/pdf", request.FileName)
End Function
Public Class TemplateRequest
Public Property Template As String
Public Property Data As Dictionary(Of String, String)
Public Property FileName As String = "document.pdf"
End ClassPara cenários de modelos mais avançados com Razor, Handlebars ou outros mecanismos, consulte a documentação de HTML para PDF do IronPDF . Você também pode explorar a conversão de CSHTML para PDF para aplicativos MVC e de Razor para PDF para aplicativos Blazor .
Ao construir uma API de PDF para produção, o desempenho é crucial. Aqui estão as principais estratégias de otimização:
Ao desenvolver projetos que envolvam o uso de operações de entrada/saída, é aconselhável utilizar programação assíncrona. Isso é especialmente útil se o conteúdo do seu PDF vier de fontes externas, como:
Essas operações podem bloquear uma thread, mas o uso de async impede que a thread da sua API fique ociosa.
Exemplo:
public async Task<byte[]> GeneratePdfFromHtmlAsync(string htmlContent)
{
return await Task.Run(() =>
{
var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
return pdf.BinaryData;
});
}Imports System.Threading.Tasks
Public Async Function GeneratePdfFromHtmlAsync(htmlContent As String) As Task(Of Byte())
Return Await Task.Run(Function()
Dim pdf = _renderer.RenderHtmlAsPdf(htmlContent)
Return pdf.BinaryData
End Function)
End FunctionConfigure o IronPDF para obter o melhor desempenho:
_renderer.RenderingOptions.EnableJavaScript = false; // If JS not needed
_renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
_renderer.RenderingOptions.RenderDelay = 0; // Remove if no JS
_renderer.RenderingOptions.Timeout = 30; // Set reasonable timeoutnetA segurança é essencial para qualquer API de produção. Aqui está uma abordagem simples para autenticação por chave de API:
// Middleware/ApiKeyMiddleware.cs
public class ApiKeyMiddleware
{
private readonly RequestDelegate _next;
private const string ApiKeyHeader = "X-API-Key";
public ApiKeyMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
if (!context.Request.Headers.TryGetValue(ApiKeyHeader, out var apiKey))
{
context.Response.StatusCode = 401;
await context.Response.WriteAsync("API Key required");
return;
}
// Validate API key (in production, check against database)
var validApiKey = context.RequestServices
.GetRequiredService<IConfiguration>()["ApiKey"];
if (apiKey != validApiKey)
{
context.Response.StatusCode = 403;
await context.Response.WriteAsync("Invalid API Key");
return;
}
await _next(context);
}
}
// In Program.cs
app.UseMiddleware<ApiKeyMiddleware>();Imports Microsoft.AspNetCore.Http
Imports Microsoft.Extensions.Configuration
Imports System.Threading.Tasks
' Middleware/ApiKeyMiddleware.vb
Public Class ApiKeyMiddleware
Private ReadOnly _next As RequestDelegate
Private Const ApiKeyHeader As String = "X-API-Key"
Public Sub New(next As RequestDelegate)
_next = next
End Sub
Public Async Function InvokeAsync(context As HttpContext) As Task
Dim apiKey As String = Nothing
If Not context.Request.Headers.TryGetValue(ApiKeyHeader, apiKey) Then
context.Response.StatusCode = 401
Await context.Response.WriteAsync("API Key required")
Return
End If
' Validate API key (in production, check against database)
Dim validApiKey As String = context.RequestServices.GetRequiredService(Of IConfiguration)()("ApiKey")
If apiKey <> validApiKey Then
context.Response.StatusCode = 403
Await context.Response.WriteAsync("Invalid API Key")
Return
End If
Await _next(context)
End Function
End Class
' In Program.vb
app.UseMiddleware(Of ApiKeyMiddleware)()Para cenários de autenticação mais avançados, considere:
Vamos construir um endpoint prático para geração de faturas que demonstre uma implementação completa. Este exemplo mostra como uma API .NET PDF de produção pode gerar faturas profissionais com dados dinâmicos.
Primeiro, vamos criar um novo arquivo na nossa pasta Modelos. Aqui, eu dei o nome de Invoice.cs ao meu arquivo. Em seguida, adicione o seguinte código ao seu novo arquivo.
public class Invoice
{
public string InvoiceNumber { get; set; }
public DateTime Date { get; set; }
public string CustomerName { get; set; }
public string CustomerAddress { get; set; }
public List<InvoiceItem> Items { get; set; }
public decimal Tax { get; set; }
}
public class InvoiceItem
{
public string Description { get; set; }
public int Quantity { get; set; }
public decimal UnitPrice { get; set; }
public decimal Total => Quantity * UnitPrice;
}Public Class Invoice
Public Property InvoiceNumber As String
Public Property [Date] As DateTime
Public Property CustomerName As String
Public Property CustomerAddress As String
Public Property Items As List(Of InvoiceItem)
Public Property Tax As Decimal
End Class
Public Class InvoiceItem
Public Property Description As String
Public Property Quantity As Integer
Public Property UnitPrice As Decimal
Public ReadOnly Property Total As Decimal
Get
Return Quantity * UnitPrice
End Get
End Property
End ClassEm seguida, precisaremos criar um novo arquivo de serviço para o nosso gerador de faturas. Na sua pasta Serviços, adicione o seguinte código. No meu caso, criei um novo arquivo chamado InvoiceService.cs. Este código irá gerenciar o estilo e o layout do nosso arquivo PDF de fatura.
public class InvoiceService
{
private readonly ChromePdfRenderer _renderer;
public InvoiceService()
{
_renderer = new ChromePdfRenderer();
_renderer.RenderingOptions.MarginTop = 10;
_renderer.RenderingOptions.MarginBottom = 10;
_renderer.RenderingOptions.PrintHtmlBackgrounds = true;
}
public byte[] GenerateInvoice(Invoice invoice)
{
var html = BuildInvoiceHtml(invoice);
// Add footer with page numbers
_renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
MaxHeight = 15,
HtmlFragment = "<center><i>{page} of {total-pages}</i></center>",
DrawDividerLine = true
};
var pdf = _renderer.RenderHtmlAsPdf(html);
return pdf.BinaryData;
}
private string BuildInvoiceHtml(Invoice invoice)
{
var subtotal = invoice.Items.Sum(i => i.Total);
var taxAmount = subtotal * (invoice.Tax / 100);
var total = subtotal + taxAmount;
var itemsHtml = string.Join("", invoice.Items.Select(item =>
$@"<tr>
<td>{item.Description}</td>
<td class='text-center'>{item.Quantity}</td>
<td class='text-right'>${item.UnitPrice:F2}</td>
<td class='text-right'>${item.Total:F2}</td>
</tr>"));
return $@"
<!DOCTYPE html>
<html>
<head>
<style>
body {{font-family: Arial, sans-serif;}}
.invoice-header {{background-color: #f8f9fa;
padding: 20px;
margin-bottom: 20px;}}
table {{width: 100%;
border-collapse: collapse;}}
th, td {{padding: 10px;
border-bottom: 1px solid #ddd;}}
th {{background-color: #007bff;
color: white;}}
.text-right {{text-align: right;}}
.text-center {{text-align: center;}}
.total-section {{margin-top: 20px;
text-align: right;}}
</style>
</head>
<body>
<div class='invoice-header'>
<h1>Invoice #{invoice.InvoiceNumber}</h1>
<p>Date: {invoice.Date:yyyy-MM-dd}</p>
</div>
<div>
<h3>Bill To:</h3>
<p>{invoice.CustomerName}<br/>{invoice.CustomerAddress}</p>
</div>
<table>
<thead>
<tr>
<th>Description</th>
<th>Quantity</th>
<th>Unit Price</th>
<th>Total</th>
</tr>
</thead>
<tbody>
{itemsHtml}
</tbody>
</table>
<div class='total-section'>
<p>Subtotal: ${subtotal:F2}</p>
<p>Tax ({invoice.Tax}%): ${taxAmount:F2}</p>
<h3>Total: ${total:F2}</h3>
</div>
</body>
</html>";
}
}Por fim, você precisará criar um novo Controlador para acessar e criar uma nova Fatura usando a API.
[ApiController]
[Route("api/[controller]")]
public class InvoiceController : ControllerBase
{
private readonly InvoiceService _invoiceService;
public InvoiceController(InvoiceService invoiceService)
{
_invoiceService = invoiceService;
}
[HttpPost("generate")]
public IActionResult GenerateInvoice([FromBody] Invoice invoice)
{
try
{
var pdfBytes = _invoiceService.GenerateInvoice(invoice);
var fileName = $"Invoice_{invoice.InvoiceNumber}.pdf";
return File(pdfBytes, "application/pdf", fileName);
}
catch (Exception ex)
{
return StatusCode(500, $"Error generating invoice: {ex.Message}");
}
}
}Imports Microsoft.AspNetCore.Mvc
<ApiController>
<Route("api/[controller]")>
Public Class InvoiceController
Inherits ControllerBase
Private ReadOnly _invoiceService As InvoiceService
Public Sub New(invoiceService As InvoiceService)
_invoiceService = invoiceService
End Sub
<HttpPost("generate")>
Public Function GenerateInvoice(<FromBody> invoice As Invoice) As IActionResult
Try
Dim pdfBytes = _invoiceService.GenerateInvoice(invoice)
Dim fileName = $"Invoice_{invoice.InvoiceNumber}.pdf"
Return File(pdfBytes, "application/pdf", fileName)
Catch ex As Exception
Return StatusCode(500, $"Error generating invoice: {ex.Message}")
End Try
End Function
End Class
Embora este tutorial se concentre no desenvolvimento local, aqui está uma breve visão geral da conteinerização da sua API de PDF:
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["PdfApiService.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build
FROM build AS publish
RUN dotnet publish -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
# IronPDF requires additional dependencies on Linux
RUN apt-get update && apt-get install -y \
libgdiplus \
libc6-dev \
libx11-dev \
&& rm -rf /var/lib/apt/lists/*
ENTRYPOINT ["dotnet", "PdfApiService.dll"]The provided code is a Dockerfile written for building and running a .NET application, not C# code. Dockerfiles are not converted to VB.NET as they are not programming language code but configuration scripts for Docker. If you have C# code that needs conversion to VB.NET, please provide that code instead.Para obter guias de implantação detalhados para sua API .NET PDF, consulte:
Para um programa mais tolerante a falhas, as melhores práticas consistem em implementar um manipulador de erros global para respostas de erro consistentes, como as abaixo:
// Middleware/ErrorHandlingMiddleware.cs
public class ErrorHandlingMiddleware
{
private readonly RequestDelegate _next;
public ErrorHandlingMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
try
{
await _next(context);
}
catch (Exception ex)
{
await HandleExceptionAsync(context, ex);
}
}
private static async Task HandleExceptionAsync(HttpContext context, Exception ex)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = 500;
var response = new
{
error = "An error occurred processing your request",
message = ex.Message
};
await context.Response.WriteAsync(JsonSerializer.Serialize(response));
}
}Imports System.Text.Json
Imports Microsoft.AspNetCore.Http
Imports System.Threading.Tasks
Public Class ErrorHandlingMiddleware
Private ReadOnly _next As RequestDelegate
Public Sub New(next As RequestDelegate)
_next = next
End Sub
Public Async Function InvokeAsync(context As HttpContext) As Task
Try
Await _next(context)
Catch ex As Exception
Await HandleExceptionAsync(context, ex)
End Try
End Function
Private Shared Async Function HandleExceptionAsync(context As HttpContext, ex As Exception) As Task
context.Response.ContentType = "application/json"
context.Response.StatusCode = 500
Dim response = New With {
.error = "An error occurred processing your request",
.message = ex.Message
}
Await context.Response.WriteAsync(JsonSerializer.Serialize(response))
End Function
End ClassPara cenários específicos de resolução de problemas do IronPDF , consulte o guia de resolução de problemas do IronPDF .
Você acabou de criar uma API .NET PDF robusta usando ASP.NET Core e IronPDF , capaz de lidar com diversos cenários de geração de documentos. Esta API REST fornece uma base sólida para operações centralizadas de PDF em seus aplicativos.
Principais conclusões:
O IronPDF permite que os desenvolvedores criem documentos PDF, salvem arquivos PDF e convertam HTML de forma eficiente, tornando-se a API de documentos PDF essencial para aplicativos modernos do .NET Framework .
Pronto para implementar o IronPDF em sua API de PDF .NET de produção? Eis as suas próximas ações:
Crie sua API de PDF for .NET hoje mesmo e simplifique a geração de documentos em todo o seu ecossistema de aplicativos com o IronPDF!
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.
