GUIDES DE MIGRATION

Comment migrer d'Api2pdf vers IronPDF en C#

Mis à jour:1 février 2026

Api2pdf propose un service cloud de génération de PDF, mais l'envoi de documents sensibles à des serveurs externes peut engendrer des risques de sécurité, des problèmes de conformité et des coûts récurrents qui peuvent s'accumuler. Ce guide décrit en détail la migration d'Api2pdf vers IronPDF, une bibliothèque PDF .NET native qui traite les documents intégralement sur votre infrastructure, éliminant ainsi les problèmes de transmission de données et transformant les coûts par conversion en un investissement unique.

Pourquoi envisager de migrer depuis Api2pdf ?

Bien qu'Api2pdf offre une génération de PDF pratique basée sur le cloud, plusieurs facteurs incitent les équipes de développement à rechercher des alternatives sur site pour leurs besoins en matière de génération de PDF.

Problèmes de sécurité et de conformité

Api2pdf fonctionne comme un service basé sur le cloud où vos documents et HTML sensibles sont envoyés à des serveurs tiers pour être traités. Cela pose des problèmes importants aux organisations qui traitent des données réglementées.

Risque	Api2pdf	IronPDF
Transmission de données	Tout le contenu est envoyé à des serveurs externes	Traitements locaux sur votre infrastructure
Conformité RGPD	Les données dépassent les juridictions	Les données ne quittent jamais votre environnement
Conformité à la loi sur la protection des données personnelles	PHI transmis à l'extérieur	Les PHI restent dans vos systèmes
SOC 2	Dépendance à l'égard de tiers	Contrôle total du traitement des données
PCI DSS	Données de cartes potentiellement exposées	Pas de transmission externe

Accumulation des coûts au fil du temps

Api2pdf facture environ 0,005 $ par conversion indéfiniment, tandis qu'IronPDF propose une licence perpétuelle unique. Pour les applications générant des volumes PDF importants, la différence de coût devient substantielle :

Volume	Api2pdf(annuel)	IronPDF(ponctuel)
10 000 PDF/mois	~600$/an	749 $ (Lite)
50 000 PDF/mois	~3 000 $/an	749 $ (Lite)
100 000 PDF/mois	~6 000 $/an	1 499 $ (Plus)

IronPDF est rentabilisé en quelques mois pour la plupart des applications de production.

Performance et disponibilité

Api2pdf nécessite des allers-retours sur le réseau qui ajoutent 2 à 5 secondes de latence à chaque demande de génération de PDF. IronPDF traite localement en 100-500 millisecondes. En outre, IronPDF fonctionne entièrement hors ligne et dans des environnements à air comprimé, ce qui est essentiel pour les applications qui ne peuvent pas dépendre de la disponibilité d'un service externe.

Api2pdfvs. IronPDF: Principales différences

Aspect	Api2pdf	IronPDF
Traitement des données	Envoyée à des serveurs cloud tiers	Traitée localement sur votre infrastructure
Tarification	Paiement à la conversion (~$0.005/PDF)	Licence perpétuelle à usage unique
Latence	2 à 5 secondes (aller-retour sur le réseau)	100-500ms (traitement local)
Offline	Non disponible	Fonctionne entièrement hors ligne
Installation	Clé API + client HTTP	Simple Paquet NuGet
Conformité	Préoccupations liées au GDPR/HIPAA (les données quittent le réseau)	Contrôle total de la conformité

Processus de migration étape par étape

Étape 1 : Mise à jour des paquets NuGet

Supprimez le paquet Api2pdfet installez 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

Ou via la console du Package Manager :

Uninstall-Package Api2Pdf
Install-Package IronPdf

Étape 2 : Mise à jour des références aux espaces de noms

Remplacer les espaces de noms Api2pdfpar 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;

Imports IronPdf
Imports IronPdf.Rendering

$vbLabelText $csharpLabel

Étape 3 : configuration de la clé de licence

Définir la clé de licence IronPDF au démarrage de l'application :

// 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" }

' 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

Etape 4 : Supprimer la configuration de la clé API

IronPDF s'exécute localement et ne nécessite pas de clés 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();

' Remove this Api2pdfpattern
Dim client = New Api2PdfClient("API_KEY")

' Just create the renderer directly
Dim renderer = New ChromePdfRenderer()

$vbLabelText $csharpLabel

Référence complète de migration des API

Mappage des classes de base

Classe Api2pdf	Équivalent d'IronPDF
`Api2PdfClient`	`ChromePdfRenderer`
`Api2PdfResult`	`PdfDocument`
`HeadlessChromeOptions`	`ChromePdfRenderOptions`

Mise en correspondance des méthodes

Méthode Api2pdf	Méthode IronPDF
`client.HeadlessChrome.FromHtmlAsync(html)`	`renderer.RenderHtmlAsPdf(html)`
`client.HeadlessChrome.FromUrlAsync(url)`	`renderer.RenderUrlAsPdf(url)`
`response.Pdf` (URL)	`pdf.SaveAs(path)`
`response.Pdf` (télécharger)	`pdf.BinaryData`
`client.PdfSharp.MergePdfsAsync(urls)`	`PdfDocument.Merge(pdfs)`
`client.PdfSharp.SetPasswordAsync(url, pwd)`	`pdf.SecuritySettings.OwnerPassword`

Mappage des options de rendu

Option Api2pdf	Option IronPDF
`Landscape = true`	`RenderingOptions.PaperOrientation = Landscape`
`PageSize = "A4"`	`RenderingOptions.PaperSize = PdfPaperSize.A4`
`PrintBackground = true`	`RenderingOptions.PrintHtmlBackgrounds = true`
`MarginTop`, etc.	`RenderingOptions.MarginTop`, etc.
`Delay = 5000`	`RenderingOptions.WaitFor.RenderDelay(5000)`

Exemples de migration de code

Conversion HTML en PDF

L'opération Api2pdfla plus courante illustre le Shift fondamental : des appels d'API cloud au traitement local.

Mise en œuvre d'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);
    }
}

Imports System
Imports System.Threading.Tasks
Imports Api2Pdf.DotNet

Module Program
    Async Function Main(args As String()) As Task
        Dim a2pClient = New Api2PdfClient("your-api-key")
        Dim apiResponse = Await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Hello World</h1>")
        Console.WriteLine(apiResponse.Pdf)
    End Function
End Module

$vbLabelText $csharpLabel

Mise en œuvre d'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");
    }
}

Imports System
Imports IronPdf

Class Program
    Shared Sub Main(ByVal args As String())
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>")
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

$vbLabelText $csharpLabel

IronPDF élimine les allers-retours sur le réseau, la gestion des clés API et l'étape de téléchargement séparée requise par le modèle de réponse basé sur l'URL d'Api2pdf.

Conversion d'URL en PDF

Mise en œuvre d'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);
    }
}

Imports System
Imports System.Threading.Tasks
Imports Api2Pdf.DotNet

Module Program
    Async Function Main(args As String()) As Task
        Dim a2pClient = New Api2PdfClient("your-api-key")
        Dim apiResponse = Await a2pClient.HeadlessChrome.FromUrlAsync("https://www.example.com")
        Console.WriteLine(apiResponse.Pdf)
    End Function
End Module

$vbLabelText $csharpLabel

Mise en œuvre d'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");
    }
}

Imports System
Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("PDF created from URL successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

Fichier HTML vers PDF avec options

Mise en œuvre d'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);
    }
}

no response after 91 seconds

$vbLabelText $csharpLabel

Mise en œuvre d'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");
    }
}

Imports System
Imports System.IO
Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Landscape
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
        Dim html As String = File.ReadAllText("input.html")
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created with options successfully")
    End Sub
End Module

$vbLabelText $csharpLabel

IronPDF configure les options de rendu directement sur l'objet de rendu plutôt que de les transmettre en tant que paramètre d'options distinct à chaque appel d'API.

Fusionner plusieurs fichiers PDF

Mise en œuvre d'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
}

Imports Api2Pdf.DotNet

Dim a2pClient = New Api2PdfClient("YOUR_API_KEY")

Dim pdfUrls = New List(Of String) From {
    "https://example.com/pdf1.pdf",
    "https://example.com/pdf2.pdf",
    "https://example.com/pdf3.pdf"
}

Dim request = New PdfMergeRequest With {.Urls = pdfUrls}
Dim response = Await a2pClient.PdfSharp.MergePdfsAsync(request)

If response.Success Then
    ' Download merged PDF from response.Pdf URL
End If

$vbLabelText $csharpLabel

Mise en œuvre d'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");

Imports IronPdf

' Load PDFs from files
Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
Dim pdf3 = PdfDocument.FromFile("document3.pdf")

' Merge all PDFs
Dim merged = PdfDocument.Merge(pdf1, pdf2, pdf3)
merged.SaveAs("merged.pdf")

$vbLabelText $csharpLabel

La méthode statique Merge d'IronPDF accepte directement plusieurs documents, éliminant ainsi le flux de travail basé sur les URL.

Produits PDF protégés par mot de passe

Mise en œuvre d'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"
);

Imports Api2Pdf.DotNet

Dim a2pClient = New Api2PdfClient("YOUR_API_KEY")

' Generate PDF first
Dim pdfResponse = Await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Confidential</h1>")

' Then add password protection in separate call
Dim protectedResponse = Await a2pClient.PdfSharp.SetPasswordAsync(pdfResponse.Pdf, "secretpassword")

$vbLabelText $csharpLabel

Mise en œuvre d'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");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()
Dim 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 offre un contrôle précis des permissions PDF via la propriété SecuritySettings.

En-têtes et pieds de page

Mise en œuvre d'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);

Imports Api2Pdf.DotNet

Dim a2pClient = New Api2PdfClient("YOUR_API_KEY")

Dim options = New HeadlessChromeOptions With {
    .HeaderHtml = "<div style='font-size:10px'>Company Header</div>",
    .FooterHtml = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
}

Dim response = Await a2pClient.HeadlessChrome.FromHtmlAsync(html, options)

$vbLabelText $csharpLabel

Mise en œuvre d'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");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

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

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

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("with-headers.pdf")

$vbLabelText $csharpLabel

IronPDF prend en charge les jetons d'espace réservé comme {page} et {total-pages} pour la numérotation dynamique des pages. Pour plus d'options, consultez la documentation sur les en-têtes et les pieds de page.

Intégration d'ASP.NET Core

Le modèle HTTP asynchrone d'Api2pdf diffère considérablement de la génération directe de PDF d'IronPDF.

Modèle 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);
    }
}

Imports Microsoft.AspNetCore.Mvc

<ApiController>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _client As Api2PdfClient

    Public Sub New()
        _client = New Api2PdfClient("YOUR_API_KEY")
    End Sub

    <HttpGet("generate")>
    Public Async Function GeneratePdf() As Task(Of IActionResult)
        Dim response = Await _client.HeadlessChrome.FromHtmlAsync("<h1>Report</h1>")

        If Not response.Success Then
            Return BadRequest(response.Error)
        End If

        ' Redirect to download URL
        Return Redirect(response.Pdf)
    End Function
End Class

$vbLabelText $csharpLabel

Modèle 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");
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports System.Threading.Tasks

<ApiController>
Public Class PdfController
    Inherits ControllerBase

    <HttpGet("generate")>
    Public Function GeneratePdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>")

        ' Return PDF directly - no download step needed
        Return File(pdf.BinaryData, "application/pdf", "report.pdf")
    End Function

    <HttpGet("generate-async")>
    Public Async Function GeneratePdfAsync() As Task(Of IActionResult)
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Report</h1>")

        Return File(pdf.Stream, "application/pdf", "report.pdf")
    End Function
End Class

$vbLabelText $csharpLabel

IronPDF renvoie le PDF directement via BinaryData ou Stream, éliminant le modèle de redirection vers le téléchargement.

Configuration de l'injection de dépendance

// 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);
}

' Program.vb or Startup.vb
Public Sub ConfigureServices(services As IServiceCollection)
    services.AddScoped(Of IPdfService, IronPdfService)()
End Sub

' IPdfService.vb
Public Interface IPdfService
    Function GenerateFromHtml(html As String) As PdfDocument
    Function GenerateFromHtmlAsync(html As String) As Task(Of PdfDocument)
End Interface

' IronPdfService.vb
Public Class IronPdfService
    Implements IPdfService

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer()
        _renderer.RenderingOptions.PrintHtmlBackgrounds = True
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
    End Sub

    Public Function GenerateFromHtml(html As String) As PdfDocument Implements IPdfService.GenerateFromHtml
        Return _renderer.RenderHtmlAsPdf(html)
    End Function

    Public Function GenerateFromHtmlAsync(html As String) As Task(Of PdfDocument) Implements IPdfService.GenerateFromHtmlAsync
        Return _renderer.RenderHtmlAsPdfAsync(html)
    End Function
End Class

$vbLabelText $csharpLabel

Migration du traitement des erreurs

Api2pdf utilise des contrôles d'objets de réponse. IronPDF utilise des exceptions .NET standard.

Modèle 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;
}

Imports System

Dim response = Await a2pClient.HeadlessChrome.FromHtmlAsync(html)

If Not response.Success Then
    Console.WriteLine($"Error: {response.Error}")
    Return
End If

$vbLabelText $csharpLabel

Modèle 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}");
}

Imports IronPdf.Exceptions

Try
    Dim renderer = New ChromePdfRenderer()
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs("output.pdf")
Catch ex As IronPdfLicenseException
    Console.WriteLine($"License error: {ex.Message}")
Catch ex As IronPdfRenderingException
    Console.WriteLine($"Rendering error: {ex.Message}")
Catch ex As Exception
    Console.WriteLine($"Error: {ex.Message}")
End Try

$vbLabelText $csharpLabel

Comparaison des Performances

Métrique	Api2pdf	IronPDF
Simple HTML	2-5 secondes (réseau)	100-500ms (local)
Page complexe	5-10 secondes	500ms-2s
Lot de 100	Minutes (limites de tarifs)	Secondes (parallèle)
Offline	Non disponible	Travaille entièrement
Départ à froid	Aucun	~2s (premier rendu)

Conseils pour l'optimisation des performances

// 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

Imports System.Threading.Tasks

' 1. Reuse renderer instance
Private Shared ReadOnly SharedRenderer As New ChromePdfRenderer()

Public Function GeneratePdf(html As String) As PdfDocument
    Return SharedRenderer.RenderHtmlAsPdf(html)
End Function

' 2. Parallel generation
Dim tasks = htmlDocs.Select(Function(html) Task.Run(Function() SharedRenderer.RenderHtmlAsPdf(html)))
Dim results = Await Task.WhenAll(tasks)

' 3. Disable unnecessary features for speed
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = False ' If not needed
renderer.RenderingOptions.WaitFor.RenderDelay(0) ' No delay

$vbLabelText $csharpLabel

Dépannage des problèmes de migration courants

Sujet : L'aspect du PDF est différent de celui de la sortie Api2pdf

Correspondre aux paramètres Headless de Api2pdfdans Chrome :

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);

Dim 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

Sujet : Ressources externes non chargées

Configurer les délais de chargement des ressources :

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/");

Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.AllFontsLoaded(timeout:=10000)
renderer.RenderingOptions.WaitFor.NetworkIdle(timeout:=10000)

' Or use base URL for relative paths
Dim pdf = renderer.RenderHtmlAsPdf(html, baseUrl:="https://example.com/")

$vbLabelText $csharpLabel

Problème : Fichiers PDF de grande taille

Compresser les images après la génération :

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");

renderer.RenderingOptions.ImageQuality = 80

' Or compress after generation
pdf.CompressImages(quality:=75)
pdf.SaveAs("compressed.pdf")

$vbLabelText $csharpLabel

Liste de contrôle post-migration

Après avoir effectué la migration du code, vérifiez les points suivants :

Vérifier que la qualité de la sortie PDF correspond aux attentes
Tester tous les cas limites (documents volumineux, caractères spéciaux)
Valider les indicateurs de performance (une amélioration significative devrait être constatée)
Mettre à jour les configurations Docker si nécessaire
Supprimer le compte du portail Api2pdfet les clés API
Mise à jour de la surveillance (plus besoin de suivi de la latence de l'API)
Documentez les nouveaux modèles pour votre équipe
Mise à jour des pipelines CI/CD

Protéger l'avenir de votre infrastructure PDF

À l'approche de .NET 10 et de l'introduction de nouvelles fonctionnalités du langage C# 14, le choix d'une bibliothèque PDF .NET native garantit la compatibilité avec les capacités d'exécution en constante évolution. L'engagement d'IronPDF à prendre en charge les dernières versions de .NET signifie que votre investissement dans la migration porte ses fruits lorsque les projets se prolongent jusqu'en 2025 et 2026 - sans que les coûts continus par conversion ne s'accumulent.

Ressources supplémentaires

La migration d'Api2pdf vers IronPDF transforme votre génération de PDF d'un modèle de coût par conversion dépendant du cloud à un investissement local et ponctuel. Vos documents sensibles restent sur votre infrastructure, la latence passe de quelques secondes à quelques millisecondes et vous éliminez la dépendance vis-à-vis des fournisseurs pour cette fonctionnalité essentielle de l'application.

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Articles connexes

Mis à jour1 février 2026

Comment migrer de ZetPDF à IronPDF en C#

Maîtrisez la migration de ZetPDF vers IronPDF grâce à ce guide C# complet. Passez d'une bibliothèque basée sur les coordonnées à une solution HTML-PDF moderne. Inclut des exemples de code pour la conversion HTML, la fusion de PDF et la suppression des dépendances PDFSharp.

Mis à jour1 février 2026

Comment migrer de Scryber.Core vers IronPDF en C#

Maîtrisez la migration de Scryber.Core vers IronPDF grâce à ce guide complet en C#. Passez d'une analyse XML/HTML personnalisée à un moteur de rendu moderne Chromium. Inclut des exemples de code pour la conversion HTML, le rendu d'URL et le remplacement des liaisons propriétaires.

Mis à jour1 février 2026

Comment migrer de XFINIUM.PDF vers IronPDF en C#

Maîtrisez la migration de XFINIUM.PDF vers IronPDF grâce à ce guide C# complet. Passez d'un positionnement manuel basé sur les coordonnées à un rendu HTML/CSS déclaratif. Inclut des exemples de code pour le remplacement des primitives graphiques et la mise en page automatique.

Comment migrer d'Apryse PDF vers IronPDF en C#

Comment migrer d'Apache PDFBox vers...

Mise en avant du client :

Projecteur sur les Développeurs:

Webinaires:

Essai gratuit de 30 jours

Comment migrer d'Api2pdf vers IronPDF en C#

Pourquoi envisager de migrer depuis Api2pdf ?

Problèmes de sécurité et de conformité

Accumulation des coûts au fil du temps

Performance et disponibilité

Api2pdfvs. IronPDF: Principales différences

Processus de migration étape par étape

Étape 1 : Mise à jour des paquets NuGet

Étape 2 : Mise à jour des références aux espaces de noms

Étape 3 : configuration de la clé de licence

Etape 4 : Supprimer la configuration de la clé API

Référence complète de migration des API

Mappage des classes de base

Mise en correspondance des méthodes

Mappage des options de rendu

Exemples de migration de code

Conversion HTML en PDF

Conversion d'URL en PDF

Fichier HTML vers PDF avec options

Fusionner plusieurs fichiers PDF

Produits PDF protégés par mot de passe

En-têtes et pieds de page

Intégration d'ASP.NET Core

Configuration de l'injection de dépendance

Migration du traitement des erreurs

Comparaison des Performances

Conseils pour l'optimisation des performances

Dépannage des problèmes de migration courants

Sujet : L'aspect du PDF est différent de celui de la sortie Api2pdf

Sujet : Ressources externes non chargées

Problème : Fichiers PDF de grande taille

Liste de contrôle post-migration

Protéger l'avenir de votre infrastructure PDF

Ressources supplémentaires

Équipe de soutien Iron

Essai gratuit de 30 jours

Comment migrer d'Api2pdf vers IronPDF en C#

Pourquoi envisager de migrer depuis Api2pdf ?

Problèmes de sécurité et de conformité

Accumulation des coûts au fil du temps

Performance et disponibilité

Api2pdfvs. IronPDF: Principales différences

Processus de migration étape par étape

Étape 1 : Mise à jour des paquets NuGet

Étape 2 : Mise à jour des références aux espaces de noms

Étape 3 : configuration de la clé de licence

Etape 4 : Supprimer la configuration de la clé API

Référence complète de migration des API

Mappage des classes de base

Mise en correspondance des méthodes

Mappage des options de rendu

Exemples de migration de code

Conversion HTML en PDF

Conversion d'URL en PDF

Fichier HTML vers PDF avec options

Fusionner plusieurs fichiers PDF

Produits PDF protégés par mot de passe

En-têtes et pieds de page

Intégration d'ASP.NET Core

Configuration de l'injection de dépendance

Migration du traitement des erreurs

Comparaison des Performances

Conseils pour l'optimisation des performances

Dépannage des problèmes de migration courants

Sujet : L'aspect du PDF est différent de celui de la sortie Api2pdf

Sujet : Ressources externes non chargées

Problème : Fichiers PDF de grande taille

Liste de contrôle post-migration

Protéger l'avenir de votre infrastructure PDF

Ressources supplémentaires

Articles connexes

Comment migrer de ZetPDF à IronPDF en C#

Comment migrer de Scryber.Core vers IronPDF en C#

Comment migrer de XFINIUM.PDF vers IronPDF en C#

Want to deploy IronSuite to a live project for FREE?

What’s included?

Thank You

Want to deploy IronSuite to a live project for FREE?

What’s included?

De confiance par des millions d'ingénieurs dans le monde entier

Équipe de soutien Iron