Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Guías de migración
  4. migración de api2pdfon a ironpdf
GUíAS DE MIGRACIóN

Cómo migrar de Api2pdf a IronPDF en C#

Curtis Chau
Curtis Chau
Publicado:

Api2pdf ofrece un servicio en la nube para generar archivos PDF, pero enviar documentos confidenciales a servidores externos puede conllevar riesgos de seguridad, problemas de cumplimiento normativo y costos continuos que pueden acumularse con el tiempo. Esta guía proporciona una ruta de migración detallada de Api2pdfa IronPDF, una biblioteca PDF .NET nativa que procesa documentos completamente en su propia infraestructura, eliminando las preocupaciones por la transmisión de datos y convirtiendo los costos por conversión en una inversión única.

¿Por qué considerar migrar desde Api2pdf?

Si bien Api2pdfproporciona una conveniente generación de PDF basada en la nube, varios factores llevan a los equipos de desarrollo a buscar alternativas locales para sus necesidades de generación de PDF.

Preocupaciones de seguridad y cumplimiento

Api2pdf funciona como un servicio basado en la nube en el que el HTML y los documentos confidenciales se envían a servidores de terceros para su procesamiento. Esto plantea importantes problemas a las organizaciones que manejan datos regulados.

Riesgo Api2pdf IronPDF
Transmisión de datos Todo el contenido se envía a servidores externos Procesa localmente en tu infraestructura
Cumplimiento del GDPR Los datos cruzan jurisdicciones Los datos nunca salen de su entorno
Cumplimiento de la HIPAA PHI transmitida externamente PHI permanece dentro de sus sistemas
SOC 2 Dependencia de terceros Control total sobre el manejo de datos
PCI DSS Datos de tarjetas potencialmente expuestos Sin transmisión externa

Acumulación de costes a lo largo del tiempo

Api2pdf cobra aproximadamente 0,005 dólares por conversión de forma indefinida, mientras queIronPDFofrece una licencia perpetua única. En el caso de las aplicaciones que generan grandes volúmenes de PDF, la diferencia de coste es considerable:

Volumen Api2pdf(anual) IronPDF(una sola vez)
10.000 PDF/mes ~600 $/año 749 $ (Lite)
50.000 PDF/mes ~3.000 $/año 749 $ (Lite)
100.000 PDF al mes ~6.000 $/año 1.499 $ (Plus)

IronPDF se amortiza en meses para la mayoría de las aplicaciones de producción.

Rendimiento y disponibilidad

Api2pdf requiere viajes de ida y vuelta por la red que añaden de 2 a 5 segundos de latencia a cada solicitud de generación de PDF.IronPDFprocesa localmente en 100-500 milisegundos. Además,IronPDFfunciona totalmente fuera de línea y en entornos aislados, algo fundamental para las aplicaciones que no pueden depender de la disponibilidad de servicios externos.

Api2pdffrente a IronPDF: Diferencias clave

Aspecto Api2pdf IronPDF
Manejo de datos Envío a servidores en la nube de terceros Procesado localmente en su infraestructura
Precios Pago por conversión (~0,005 $/PDF) Licencia perpetua única
Latencia 2-5 segundos (ida y vuelta en red) 100-500ms (procesamiento local)
Offline No disponible Funciona totalmente fuera de línea
Instalación Clave API + cliente HTTP Paquete simple NuGet
Cumplimiento Preocupaciones GDPR/HIPAA (los datos salen de la red) Control total de la conformidad

Proceso de migración paso a paso

Paso 1: Actualizar paquetes NuGet

Elimine el paquete Api2pdfe instale IronPDF:

# Remove Api2pdf
dotnet remove package Api2Pdf

# Install IronPDF
dotnet add package IronPdf
# Remove Api2pdf
dotnet remove package Api2Pdf

# Install IronPDF
dotnet add package IronPdf
SHELL

O a través de Package Manager Console:

Uninstall-Package Api2Pdf
Install-Package IronPdf

Paso 2: Actualizar referencias de espacios de nombres

Sustituya los espacios de nombres Api2pdfpor IronPDF:

// Remove these
using Api2Pdf;
using Api2Pdf.DotNet;

// Add these
using IronPdf;
using IronPdf.Rendering;
// Remove these
using Api2Pdf;
using Api2Pdf.DotNet;

// Add these
using IronPdf;
using IronPdf.Rendering;
$vbLabelText   $csharpLabel

Paso 3: Configurar la clave de licencia

Establezca la clave de licencia deIronPDFal iniciar la aplicación:

// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";

// Or configure via appsettings.json:
// { "IronPdf.LicenseKey": "YOUR-IRONPDF-LICENSE-KEY" }
// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";

// Or configure via appsettings.json:
// { "IronPdf.LicenseKey": "YOUR-IRONPDF-LICENSE-KEY" }
$vbLabelText   $csharpLabel

Paso 4: Eliminar la configuración de la clave API

IronPDF se ejecuta localmente y no requiere claves API:

// Remove this Api2pdfpattern
var client = new Api2PdfClient("API_KEY");

// Just create the renderer directly
var renderer = new ChromePdfRenderer();
// Remove this Api2pdfpattern
var client = new Api2PdfClient("API_KEY");

// Just create the renderer directly
var renderer = new ChromePdfRenderer();
$vbLabelText   $csharpLabel

Referencia completa de migración de API

Mapeo de clases principales

Clase Api2pdf Equivalente de IronPDF Notas
<código>Api2PdfClient` <código>ChromePdfRenderer Clase principal de renderización
<código>Api2PdfResult Documento PDF Representa el PDF
<código>HeadlessChromeOptions` <código>ChromePdfRenderOptions Configuración de la renderización

Métodos

Método Api2pdf Método IronPDF Notas
client.HeadlessChrome.FromHtmlAsync(html) renderer.RenderHtmlAsPdf(html) HTML a PDF
client.HeadlessChrome.FromUrlAsync(url) <código>renderer.RenderUrlAsPdf(url)` URL a PDF
respuesta.Pdf (URL) <código>pdf.SaveAs(ruta)` Guardar en archivo
respuesta.Pdf (descargar) <código>pdf.BinaryData` Obtener como matriz de bytes
client.PdfSharp.MergePdfsAsync(urls) <código>PdfDocument.Merge(pdfs)` Fusionar PDF
<código>client.PdfSharp.SetPasswordAsync(url, pwd) <código>pdf.SecuritySettings.OwnerPassword Protección con contraseña

Mapeo de opciones de renderizado

Opción Api2pdf Opción IronPDF Notas
<código>Landscape = true <código>RenderingOptions.PaperOrientation = Landscape Orientación de la página
Tamaño de página = "A4" <código>RenderingOptions.PaperSize = PdfPaperSize.A4` Tamaño del papel
<código>PrintBackground = true RenderingOptions.PrintHtmlBackgrounds = true Colores de fondo
MarginTop, etc. RenderingOptions.MarginTop, etc. Márgenes en mm
Retraso = 5000 <código>RenderingOptions.WaitFor.RenderDelay(5000)` Espere antes de renderizar

Ejemplos de migración de código

Conversión de HTML a PDF

La operación Api2pdfmás común demuestra el cambio fundamental: de llamadas API en la nube al procesamiento local.

Implementación de API2pdf:

// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.Threading.Tasks;
using Api2Pdf.DotNet;

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        var apiResponse = await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Hello World</h1>");
        Console.WriteLine(apiResponse.Pdf);
    }
}
// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.Threading.Tasks;
using Api2Pdf.DotNet;

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        var apiResponse = await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Hello World</h1>");
        Console.WriteLine(apiResponse.Pdf);
    }
}
$vbLabelText   $csharpLabel

Implementación de IronPDF:

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
$vbLabelText   $csharpLabel

IronPDF elimina la ida y vuelta por la red, la gestión de claves API y el paso de descarga independiente que requiere el patrón de respuesta basado en URL de Api2pdf.

Conversión de URL a PDF

Implementación de API2pdf:

// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.Threading.Tasks;
using Api2Pdf.DotNet;

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        var apiResponse = await a2pClient.HeadlessChrome.FromUrlAsync("https://www.example.com");
        Console.WriteLine(apiResponse.Pdf);
    }
}
// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.Threading.Tasks;
using Api2Pdf.DotNet;

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        var apiResponse = await a2pClient.HeadlessChrome.FromUrlAsync("https://www.example.com");
        Console.WriteLine(apiResponse.Pdf);
    }
}
$vbLabelText   $csharpLabel

Implementación de IronPDF:

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF created from URL successfully");
    }
}
// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF created from URL successfully");
    }
}
$vbLabelText   $csharpLabel

Archivo HTML a PDF con opciones

Implementación de API2pdf:

// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.IO;
using System.Threading.Tasks;
using Api2Pdf.DotNet;

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        string html = File.ReadAllText("input.html");
        var options = new HeadlessChromeOptions
        {
            Landscape = true,
            PrintBackground = true
        };
        var apiResponse = await a2pClient.HeadlessChrome.FromHtmlAsync(html, options);
        Console.WriteLine(apiResponse.Pdf);
    }
}
// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.IO;
using System.Threading.Tasks;
using Api2Pdf.DotNet;

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        string html = File.ReadAllText("input.html");
        var options = new HeadlessChromeOptions
        {
            Landscape = true,
            PrintBackground = true
        };
        var apiResponse = await a2pClient.HeadlessChrome.FromHtmlAsync(html, options);
        Console.WriteLine(apiResponse.Pdf);
    }
}
$vbLabelText   $csharpLabel

Implementación de IronPDF:

// NuGet: Install-Package IronPdf
using System;
using System.IO;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
        string html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created with options successfully");
    }
}
// NuGet: Install-Package IronPdf
using System;
using System.IO;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
        string html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created with options successfully");
    }
}
$vbLabelText   $csharpLabel

IronPDF configura las opciones de renderizado directamente en el objeto renderizador en lugar de pasarlas como un parámetro de opciones independiente a cada llamada a la API.

Fusión de varios PDF

Implementación de API2pdf:

using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

var pdfUrls = new List<string>
{
    "https://example.com/pdf1.pdf",
    "https://example.com/pdf2.pdf",
    "https://example.com/pdf3.pdf"
};

var request = new PdfMergeRequest { Urls = pdfUrls };
var response = await a2pClient.PdfSharp.MergePdfsAsync(request);

if (response.Success)
{
    // Download merged PDF from response.Pdf URL
}
using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

var pdfUrls = new List<string>
{
    "https://example.com/pdf1.pdf",
    "https://example.com/pdf2.pdf",
    "https://example.com/pdf3.pdf"
};

var request = new PdfMergeRequest { Urls = pdfUrls };
var response = await a2pClient.PdfSharp.MergePdfsAsync(request);

if (response.Success)
{
    // Download merged PDF from response.Pdf URL
}
$vbLabelText   $csharpLabel

Implementación de IronPDF:

using IronPdf;

// Load PDFs from files
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var pdf3 = PdfDocument.FromFile("document3.pdf");

// Merge all PDFs
var merged = PdfDocument.Merge(pdf1, pdf2, pdf3);
merged.SaveAs("merged.pdf");
using IronPdf;

// Load PDFs from files
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var pdf3 = PdfDocument.FromFile("document3.pdf");

// Merge all PDFs
var merged = PdfDocument.Merge(pdf1, pdf2, pdf3);
merged.SaveAs("merged.pdf");
$vbLabelText   $csharpLabel

El método estático Merge deIronPDFacepta varios documentos directamente, eliminando el flujo de trabajo basado en URL.

PDF protegidos por contraseña

Implementación de API2pdf:

using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

// Generate PDF first
var pdfResponse = await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Confidential</h1>");

// Then add password protection in separate call
var protectedResponse = await a2pClient.PdfSharp.SetPasswordAsync(
    pdfResponse.Pdf,
    "secretpassword"
);
using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

// Generate PDF first
var pdfResponse = await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Confidential</h1>");

// Then add password protection in separate call
var protectedResponse = await a2pClient.PdfSharp.SetPasswordAsync(
    pdfResponse.Pdf,
    "secretpassword"
);
$vbLabelText   $csharpLabel

Implementación de IronPDF:

using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

// Set security in one step
pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

pdf.SaveAs("protected.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

// Set security in one step
pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

pdf.SaveAs("protected.pdf");
$vbLabelText   $csharpLabel

IronPDF proporciona un control granular sobre los permisos de PDF a través de la propiedad SecuritySettings.

Cabeceras y pies de página

Implementación de API2pdf:

using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

var options = new HeadlessChromeOptions
{
    HeaderHtml = "<div style='font-size:10px'>Company Header</div>",
    FooterHtml = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
};

var response = await a2pClient.HeadlessChrome.FromHtmlAsync(html, options);
using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

var options = new HeadlessChromeOptions
{
    HeaderHtml = "<div style='font-size:10px'>Company Header</div>",
    FooterHtml = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
};

var response = await a2pClient.HeadlessChrome.FromHtmlAsync(html, options);
$vbLabelText   $csharpLabel

Implementación de IronPDF:

using IronPdf;

var renderer = new ChromePdfRenderer();

// HTML headers and footers with full styling
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='font-size:10px; text-align:center;'>Company Header</div>",
    DrawDividerLine = true
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='font-size:10px; text-align:center;'>Page {page} of {total-pages}</div>",
    DrawDividerLine = true
};

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("with-headers.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

// HTML headers and footers with full styling
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='font-size:10px; text-align:center;'>Company Header</div>",
    DrawDividerLine = true
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='font-size:10px; text-align:center;'>Page {page} of {total-pages}</div>",
    DrawDividerLine = true
};

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("with-headers.pdf");
$vbLabelText   $csharpLabel

IronPDF admite marcadores de posición como {page} y {total-pages} para la numeración dinámica de páginas. Para más opciones, consulte la documentación sobre encabezados y pies de página.

Integración con .NET Core

El patrón HTTP asíncrono de Api2pdfdifiere significativamente de la generación directa de PDF de IronPDF.

Patrón Api2pdf:

[ApiController]
public class PdfController : ControllerBase
{
    private readonly Api2PdfClient _client;

    public PdfController()
    {
        _client = new Api2PdfClient("YOUR_API_KEY");
    }

    [HttpGet("generate")]
    public async Task<IActionResult> GeneratePdf()
    {
        var response = await _client.HeadlessChrome.FromHtmlAsync("<h1>Report</h1>");

        if (!response.Success)
            return BadRequest(response.Error);

        // Redirect to download URL
        return Redirect(response.Pdf);
    }
}
[ApiController]
public class PdfController : ControllerBase
{
    private readonly Api2PdfClient _client;

    public PdfController()
    {
        _client = new Api2PdfClient("YOUR_API_KEY");
    }

    [HttpGet("generate")]
    public async Task<IActionResult> GeneratePdf()
    {
        var response = await _client.HeadlessChrome.FromHtmlAsync("<h1>Report</h1>");

        if (!response.Success)
            return BadRequest(response.Error);

        // Redirect to download URL
        return Redirect(response.Pdf);
    }
}
$vbLabelText   $csharpLabel

Patrón IronPDF:

[ApiController]
public class PdfController : ControllerBase
{
    [HttpGet("generate")]
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>");

        // Return PDF directly - no download step needed
        return File(pdf.BinaryData, "application/pdf", "report.pdf");
    }

    [HttpGet("generate-async")]
    public async Task<IActionResult> GeneratePdfAsync()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Report</h1>");

        return File(pdf.Stream, "application/pdf", "report.pdf");
    }
}
[ApiController]
public class PdfController : ControllerBase
{
    [HttpGet("generate")]
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>");

        // Return PDF directly - no download step needed
        return File(pdf.BinaryData, "application/pdf", "report.pdf");
    }

    [HttpGet("generate-async")]
    public async Task<IActionResult> GeneratePdfAsync()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Report</h1>");

        return File(pdf.Stream, "application/pdf", "report.pdf");
    }
}
$vbLabelText   $csharpLabel

IronPDF devuelve el PDF directamente a través de BinaryData o Stream, eliminando el patrón de redirección a descarga.

Configuración de la inyección de dependencias

// Program.cs or Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IPdfService, IronPdfService>();
}

// IPdfService.cs
public interface IPdfService
{
    PdfDocument GenerateFromHtml(string html);
    Task<PdfDocument> GenerateFromHtmlAsync(string html);
}

// IronPdfService.cs
public class IronPdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;

    public IronPdfService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    }

    public PdfDocument GenerateFromHtml(string html) =>
        _renderer.RenderHtmlAsPdf(html);

    public Task<PdfDocument> GenerateFromHtmlAsync(string html) =>
        _renderer.RenderHtmlAsPdfAsync(html);
}
// Program.cs or Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IPdfService, IronPdfService>();
}

// IPdfService.cs
public interface IPdfService
{
    PdfDocument GenerateFromHtml(string html);
    Task<PdfDocument> GenerateFromHtmlAsync(string html);
}

// IronPdfService.cs
public class IronPdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;

    public IronPdfService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    }

    public PdfDocument GenerateFromHtml(string html) =>
        _renderer.RenderHtmlAsPdf(html);

    public Task<PdfDocument> GenerateFromHtmlAsync(string html) =>
        _renderer.RenderHtmlAsPdfAsync(html);
}
$vbLabelText   $csharpLabel

Migración de la gestión de errores

Api2pdf utiliza comprobaciones de objetos de respuesta.IronPDFutiliza las excepciones estándar de .NET.

Patrón Api2pdf:

var response = await a2pClient.HeadlessChrome.FromHtmlAsync(html);

if (!response.Success)
{
    Console.WriteLine($"Error: {response.Error}");
    return;
}
var response = await a2pClient.HeadlessChrome.FromHtmlAsync(html);

if (!response.Success)
{
    Console.WriteLine($"Error: {response.Error}");
    return;
}
$vbLabelText   $csharpLabel

Patrón IronPDF:

try
{
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (IronPdf.Exceptions.IronPdfLicenseException ex)
{
    Console.WriteLine($"License error: {ex.Message}");
}
catch (IronPdf.Exceptions.IronPdfRenderingException ex)
{
    Console.WriteLine($"Rendering error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
try
{
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (IronPdf.Exceptions.IronPdfLicenseException ex)
{
    Console.WriteLine($"License error: {ex.Message}");
}
catch (IronPdf.Exceptions.IronPdfRenderingException ex)
{
    Console.WriteLine($"Rendering error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
$vbLabelText   $csharpLabel

Comparación de prestaciones

Métrica Api2pdf IronPDF
Simple HTML 2-5 segundos (red) 100-500ms (local)
Página compleja 5-10 segundos 500ms-2s
Lote de 100 Minutos (límites de tarifa) Segundos (paralelo)
Offline No disponible Trabajo completo
Inicio en frío Ninguno ~2s (primer renderizado)

Consejos para optimizar el rendimiento

// 1. Reuse renderer instance
private static readonly ChromePdfRenderer SharedRenderer = new ChromePdfRenderer();

public PdfDocument GeneratePdf(string html)
{
    return SharedRenderer.RenderHtmlAsPdf(html);
}

// 2. Parallel generation
var tasks = htmlDocs.Select(html =>
    Task.Run(() => SharedRenderer.RenderHtmlAsPdf(html)));
var results = await Task.WhenAll(tasks);

// 3. Disable unnecessary features for speed
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = false; // If not needed
renderer.RenderingOptions.WaitFor.RenderDelay(0);   // No delay
// 1. Reuse renderer instance
private static readonly ChromePdfRenderer SharedRenderer = new ChromePdfRenderer();

public PdfDocument GeneratePdf(string html)
{
    return SharedRenderer.RenderHtmlAsPdf(html);
}

// 2. Parallel generation
var tasks = htmlDocs.Select(html =>
    Task.Run(() => SharedRenderer.RenderHtmlAsPdf(html)));
var results = await Task.WhenAll(tasks);

// 3. Disable unnecessary features for speed
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = false; // If not needed
renderer.RenderingOptions.WaitFor.RenderDelay(0);   // No delay
$vbLabelText   $csharpLabel

Solución de problemas comunes de migración

Asunto: El PDF se ve diferente de la salida de Api2pdf

Coincidir con la configuración Headless Chrome de Api2pdf:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
renderer.RenderingOptions.ViewPortWidth = 1280;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
renderer.RenderingOptions.ViewPortWidth = 1280;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
$vbLabelText   $csharpLabel

Asunto: Los recursos externos no se cargan

Configurar tiempos de espera de carga de recursos:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.AllFontsLoaded(timeout: 10000);
renderer.RenderingOptions.WaitFor.NetworkIdle(timeout: 10000);

// Or use base URL for relative paths
var pdf = renderer.RenderHtmlAsPdf(html, baseUrl: "https://example.com/");
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.AllFontsLoaded(timeout: 10000);
renderer.RenderingOptions.WaitFor.NetworkIdle(timeout: 10000);

// Or use base URL for relative paths
var pdf = renderer.RenderHtmlAsPdf(html, baseUrl: "https://example.com/");
$vbLabelText   $csharpLabel

Asunto: Archivos PDF de gran tamaño

Comprima las imágenes después de generarlas:

renderer.RenderingOptions.ImageQuality = 80;

// Or compress after generation
pdf.CompressImages(quality: 75);
pdf.SaveAs("compressed.pdf");
renderer.RenderingOptions.ImageQuality = 80;

// Or compress after generation
pdf.CompressImages(quality: 75);
pdf.SaveAs("compressed.pdf");
$vbLabelText   $csharpLabel

Lista de comprobación posterior a la migración

Después de completar la migración del código, verifique lo siguiente:

  • Verificación de que la calidad del PDF se ajusta a las expectativas
  • Probar todos los casos extremos (documentos grandes, caracteres especiales)
  • Validar las métricas de rendimiento (debería ver una mejora significativa)
  • Actualizar las configuraciones de Docker si corresponde
  • Eliminar la cuenta del portal Api2pdfy las claves API
  • Monitoreo de actualizaciones (ya no es necesario el seguimiento de latencia de API)
  • Documenta nuevos patrones para tu equipo
  • Actualizar los pipelines de CI/CD

Proteja su infraestructura PDF

Con .NET 10 a la vuelta de la esquina y C# 14 introduciendo nuevas características del lenguaje, elegir una biblioteca PDF nativa de .NET garantiza la compatibilidad con las capacidades de tiempo de ejecución en evolución. El compromiso deIronPDFde admitir las últimas versiones de .NET significa que su inversión en migración le reportará beneficios cuando los proyectos se extiendan hasta 2025 y 2026, sin que se acumulen los costes continuos por conversión.

Recursos adicionales

La migración de Api2pdfaIronPDFtransforma la generación de PDF de un modelo de costes por conversión dependiente de la nube a una inversión local única. Sus documentos confidenciales permanecen en su infraestructura, la latencia se reduce de segundos a milisegundos y se elimina la dependencia del proveedor para esta capacidad crítica de la aplicación.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis