Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Guides de migration
  4. migrer d'api2pdfon à IronPdf
GUIDES DE MIGRATION

Comment migrer d'Api2pdf vers IronPDF en C#

Curtis Chau
Curtis Chau
Mis à jour:

Migrer d'Api2pdf àIronPDF: Guide de migration complet en C

Api2pdf fournit un service pratique de génération de PDF basé sur le cloud, mais l'envoi de documents sensibles à des serveurs tiers crée des risques de sécurité, des défis de conformité et des coûts permanents qui s'accumulent indéfiniment. Ce guide complet propose un chemin de migration pas à pas d'Api2pdf versIronPDF- une bibliothèque PDF .NET native qui traite les documents entièrement sur votre propre infrastructure, éliminant ainsi les problèmes de transmission de données tout en convertissant les coûts par conversion en un investissement unique.

Pourquoi migrer loin d'Api2pdf?

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

Risques 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.IronPDFtraite localement en 100-500 millisecondes. En outre,IronPDFfonctionne 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 gestionnaire de paquets :

Uninstall-Package Api2Pdf
Install-Package IronPdf

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

Remplacer les espaces de noms Api2pdfparIronPDF:

// 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;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Étape 3 : configuration de la clé de licence

Définir la clé de licenceIronPDFau 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" }
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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();
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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

Mappage des classes de base

Classe Api2pdf Équivalent d'IronPDF Notes
Api2PdfClient ChromePdfRenderer Classe de rendu principale
Api2PdfResult Document PDF Représente le PDF
HeadlessChromeOptions ChromePdfRenderOptions Configuration du rendu

Mise en correspondance des méthodes

Méthode Api2pdf Méthode IronPDF Notes
client.HeadlessChrome.FromHtmlAsync(html) renderer.RenderHtmlAsPdf(html) HTML vers PDF
client.HeadlessChrome.FromUrlAsync(url) renderer.RenderUrlAsPdf(url) URL au PDF
réponse.Pdf (URL) pdf.SaveAs(path) Enregistrer dans un fichier
réponse.Pdf (télécharger) pdf.BinaryData Obtenir un tableau d'octets
client.PdfSharp.MergePdfsAsync(urls) PdfDocument.Merge(pdfs) Fusionner des PDF
client.PdfSharp.SetPasswordAsync(url, pwd) pdf.SecuritySettings.OwnerPassword Protection des mots de passe

Mappage des options de rendu

Option Api2pdf Option IronPDF Notes
Landscape = true RenderingOptions.PaperOrientation = Landscape Orientation de la page
PageSize = "A4" RenderingOptions.PaperSize = PdfPaperSize.A4 Taille du papier
PrintBackground = true RenderingOptions.PrintHtmlBackgrounds = true Couleurs de fond
MarginTop, etc. RenderingOptions.MarginTop, etc. Marges en mm
Délai = 5000 RenderingOptions.WaitFor.RenderDelay(5000) Attendre avant de rendre

Exemples de migration de code

Conversion HTML en PDF

L'opération Api2pdfla plus courante illustre le changement fondamental de paradigme - des appels d'API dans le nuage 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);
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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);
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

La méthode statique Merge d'IronPDF accepte directement plusieurs documents, éliminant ainsi le flux de travail basé sur l'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"
);
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

IronPDF permet un contrôle granulaire des autorisations PDF par le biais de 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);
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

IronPDF prend en charge les jetons placeholder tels que {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);
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

IronPDF renvoie le PDF directement via BinaryData ou Stream, éliminant ainsi 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);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Migration du traitement des erreurs

Api2pdf utilise des contrôles d'objets de réponse.IronPDFutilise 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;
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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}");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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) Seconds (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
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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);
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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/");
IRON VB CONVERTER ERROR developers@ironsoftware.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");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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 de figure (documents volumineux, caractères spéciaux)
  • [Valider les mesures de performance (une amélioration significative doit être constatée)
  • [Mise à jour des configurations Docker, le cas échéant
  • [Supprimer le compte du portail Api2pdfet les clés API
  • [La traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils pour les développeurs
  • [ ] Documenter de 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 versIronPDFtransforme 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
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 ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit