La Bibliothèque PDF C#

HTML en PDF

Online Demo Voir tous les exemples de code %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

VIDÉOS

Comment extraire le texte intégré et les images depuis des PDFs en utilisant C#

Curtis Chau

Updated: 19 juillet 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 une base de 1 $/mois plus l'utilisation mesurée (bande passante et secondes de calcul) indéfiniment, tandis qu'IronPDF offre une licence perpétuelle unique. Vérifiez les chiffres actuels sur api2pdf.com/pricing :

Composant	Api2pdf	IronPDF
Base	1 $/mois	Licence unique
Bande passante	0,001 $ par Mo	n/a (local)
Calcul	0,00019551 $ par seconde	n/a (local)
Mise à l'échelle du volume	Linéaire avec l'utilisation et la taille du fichier	Forfait (Lite ~749 $, Plus ~1 499 $, Professional ~2 999 $)

Les charges de travail plus lourdes (fichiers volumineux, pages lourdes en JS, longs temps de rendu) augmentent la facture api2pdf ; Le coût d'IronPDF est fixe après l'obtention de la licence.

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	1 $/mois de base + mesuré (0,001 $/Mo de bande passante, 0,00019551 $/sec de calcul)	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

Uninstall-Package Api2Pdf
Install-Package IronPdf

PowerShell

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

Remplacer les espaces de noms Api2pdfpar IronPDF:

// Remove these
using Api2Pdf;

// Add these
using IronPdf;
using IronPdf.Rendering;

// Remove these
using Api2Pdf;

// Add these
using IronPdf;
using IronPdf.Rendering;

Imports IronPdf
Imports IronPdf.Rendering

Imports IronPdf
Imports IronPdf.Rendering

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

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

' Or configure via appsettings.json:
' { "IronPdf.LicenseKey": "YOUR-IRONPDF-LICENSE-KEY" }

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 Api2Pdf("API_KEY");

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

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

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

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

Mappage des classes de base

Classe Api2pdf	Équivalent d'IronPDF
`Api2Pdf` (client)	`ChromePdfRenderer`
`Api2PdfResult`	`PdfDocument`
`ChromeHtmlToPdfOptions`	`ChromePdfRenderOptions`

Mise en correspondance des méthodes

Méthode Api2pdf	Méthode IronPDF
`client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest { Html = html })`	`renderer.RenderHtmlAsPdf(html)`
`client.Chrome.UrlToPdfAsync(new ChromeUrlToPdfRequest { Url = url })`	`renderer.RenderUrlAsPdf(url)`
`result.FileUrl` (URL de téléchargement)	`pdf.SaveAs(path)`
`result.GetFileBytes()`	`pdf.BinaryData`
`client.PdfSharp.MergePdfs(new PdfMergeRequest { Urls = urls })`	`PdfDocument.Merge(pdfs)`
`client.PdfSharp.SetPassword(new PdfPasswordRequest { Url, OwnerPassword })`	`pdf.SecuritySettings.OwnerPassword`

Mappage des options de rendu

Option Api2pdf	Option IronPDF
`Landscape = true`	`RenderingOptions.PaperOrientation = Landscape`
`PreferCSSPageSize = true` / `Format`	`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
using System;
using System.Threading.Tasks;
using Api2Pdf;

class Program
{
    static async Task Main(string[] args)
    {
        var client = new Api2Pdf("your-api-key");
        var result = await client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest
        {
            Html = "<h1>Hello World</h1>"
        });
        Console.WriteLine(result.FileUrl);
    }
}

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

class Program
{
    static async Task Main(string[] args)
    {
        var client = new Api2Pdf("your-api-key");
        var result = await client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest
        {
            Html = "<h1>Hello World</h1>"
        });
        Console.WriteLine(result.FileUrl);
    }
}

Imports System
Imports System.Threading.Tasks
Imports Api2Pdf

Module Program
    Async Function Main(args As String()) As Task
        Dim client = New Api2Pdf("your-api-key")
        Dim result = Await client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {
            .Html = "<h1>Hello World</h1>"
        })
        Console.WriteLine(result.FileUrl)
    End Function
End Module

Imports System
Imports System.Threading.Tasks
Imports Api2Pdf

Module Program
    Async Function Main(args As String()) As Task
        Dim client = New Api2Pdf("your-api-key")
        Dim result = Await client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {
            .Html = "<h1>Hello World</h1>"
        })
        Console.WriteLine(result.FileUrl)
    End Function
End Module

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

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

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
using System;
using System.Threading.Tasks;
using Api2Pdf;

class Program
{
    static async Task Main(string[] args)
    {
        var client = new Api2Pdf("your-api-key");
        var result = await client.Chrome.UrlToPdfAsync(new ChromeUrlToPdfRequest
        {
            Url = "https://www.example.com"
        });
        Console.WriteLine(result.FileUrl);
    }
}

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

class Program
{
    static async Task Main(string[] args)
    {
        var client = new Api2Pdf("your-api-key");
        var result = await client.Chrome.UrlToPdfAsync(new ChromeUrlToPdfRequest
        {
            Url = "https://www.example.com"
        });
        Console.WriteLine(result.FileUrl);
    }
}

Imports System
Imports System.Threading.Tasks
Imports Api2Pdf

Module Program
    Async Function Main(args As String()) As Task
        Dim client = New Api2Pdf("your-api-key")
        Dim result = Await client.Chrome.UrlToPdfAsync(New ChromeUrlToPdfRequest With {
            .Url = "https://www.example.com"
        })
        Console.WriteLine(result.FileUrl)
    End Function
End Module

Imports System
Imports System.Threading.Tasks
Imports Api2Pdf

Module Program
    Async Function Main(args As String()) As Task
        Dim client = New Api2Pdf("your-api-key")
        Dim result = Await client.Chrome.UrlToPdfAsync(New ChromeUrlToPdfRequest With {
            .Url = "https://www.example.com"
        })
        Console.WriteLine(result.FileUrl)
    End Function
End Module

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

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

Fichier HTML vers PDF avec options

Mise en œuvre d'Api2pdf:

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

class Program
{
    static async Task Main(string[] args)
    {
        var client = new Api2Pdf("your-api-key");
        string html = File.ReadAllText("input.html");
        var result = await client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest
        {
            Html = html,
            Options = new ChromeHtmlToPdfOptions
            {
                Landscape = true,
                PrintBackground = true
            }
        });
        Console.WriteLine(result.FileUrl);
    }
}

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

class Program
{
    static async Task Main(string[] args)
    {
        var client = new Api2Pdf("your-api-key");
        string html = File.ReadAllText("input.html");
        var result = await client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest
        {
            Html = html,
            Options = new ChromeHtmlToPdfOptions
            {
                Landscape = true,
                PrintBackground = true
            }
        });
        Console.WriteLine(result.FileUrl);
    }
}

Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Api2Pdf

Module Program
    Async Function Main(args As String()) As Task
        Dim client = New Api2Pdf("your-api-key")
        Dim html As String = File.ReadAllText("input.html")
        Dim result = Await client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {
            .Html = html,
            .Options = New ChromeHtmlToPdfOptions With {
                .Landscape = True,
                .PrintBackground = True
            }
        })
        Console.WriteLine(result.FileUrl)
    End Function
End Module

Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Api2Pdf

Module Program
    Async Function Main(args As String()) As Task
        Dim client = New Api2Pdf("your-api-key")
        Dim html As String = File.ReadAllText("input.html")
        Dim result = Await client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {
            .Html = html,
            .Options = New ChromeHtmlToPdfOptions With {
                .Landscape = True,
                .PrintBackground = True
            }
        })
        Console.WriteLine(result.FileUrl)
    End Function
End Module

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

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

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;

var client = new Api2Pdf("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 result = await client.PdfSharp.MergePdfsAsync(request);

if (result.Success)
{
    // Download merged PDF from result.FileUrl
}

using Api2Pdf;

var client = new Api2Pdf("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 result = await client.PdfSharp.MergePdfsAsync(request);

if (result.Success)
{
    // Download merged PDF from result.FileUrl
}

Imports Api2Pdf

Dim client As New Api2Pdf("YOUR_API_KEY")

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

Dim request As New PdfMergeRequest With {.Urls = pdfUrls}
Dim result = Await client.PdfSharp.MergePdfsAsync(request)

If result.Success Then
    ' Download merged PDF from result.FileUrl
End If

Imports Api2Pdf

Dim client As New Api2Pdf("YOUR_API_KEY")

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

Dim request As New PdfMergeRequest With {.Urls = pdfUrls}
Dim result = Await client.PdfSharp.MergePdfsAsync(request)

If result.Success Then
    ' Download merged PDF from result.FileUrl
End If

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

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

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

Produits PDF protégés par mot de passe

Mise en œuvre d'Api2pdf:

using Api2Pdf;

var client = new Api2Pdf("YOUR_API_KEY");

// Generate PDF first
var pdfResult = await client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest
{
    Html = "<h1>Confidential</h1>"
});

// Then add password protection in a second round-trip
var protectedResult = await client.PdfSharp.SetPasswordAsync(new PdfPasswordRequest
{
    Url = pdfResult.FileUrl,
    OwnerPassword = "secretpassword"
});

using Api2Pdf;

var client = new Api2Pdf("YOUR_API_KEY");

// Generate PDF first
var pdfResult = await client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest
{
    Html = "<h1>Confidential</h1>"
});

// Then add password protection in a second round-trip
var protectedResult = await client.PdfSharp.SetPasswordAsync(new PdfPasswordRequest
{
    Url = pdfResult.FileUrl,
    OwnerPassword = "secretpassword"
});

Imports Api2Pdf

Dim client = New Api2Pdf("YOUR_API_KEY")

' Generate PDF first
Dim pdfResult = Await client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {
    .Html = "<h1>Confidential</h1>"
})

' Then add password protection in a second round-trip
Dim protectedResult = Await client.PdfSharp.SetPasswordAsync(New PdfPasswordRequest With {
    .Url = pdfResult.FileUrl,
    .OwnerPassword = "secretpassword"
})

Imports Api2Pdf

Dim client = New Api2Pdf("YOUR_API_KEY")

' Generate PDF first
Dim pdfResult = Await client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {
    .Html = "<h1>Confidential</h1>"
})

' Then add password protection in a second round-trip
Dim protectedResult = Await client.PdfSharp.SetPasswordAsync(New PdfPasswordRequest With {
    .Url = pdfResult.FileUrl,
    .OwnerPassword = "secretpassword"
})

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

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

IronPDF offre un contrôle granulaire sur les permissions PDF via la propriété SecuritySettings.

En-têtes et pieds de page

Mise en œuvre d'Api2pdf:

using Api2Pdf;

var client = new Api2Pdf("YOUR_API_KEY");

var result = await client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest
{
    Html = html,
    Options = new ChromeHtmlToPdfOptions
    {
        DisplayHeaderFooter = true,
        HeaderTemplate = "<div style='font-size:10px'>Company Header</div>",
        FooterTemplate = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
    }
});

using Api2Pdf;

var client = new Api2Pdf("YOUR_API_KEY");

var result = await client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest
{
    Html = html,
    Options = new ChromeHtmlToPdfOptions
    {
        DisplayHeaderFooter = true,
        HeaderTemplate = "<div style='font-size:10px'>Company Header</div>",
        FooterTemplate = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
    }
});

Imports Api2Pdf

Dim client = New Api2Pdf("YOUR_API_KEY")

Dim result = Await client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {
    .Html = html,
    .Options = New ChromeHtmlToPdfOptions With {
        .DisplayHeaderFooter = True,
        .HeaderTemplate = "<div style='font-size:10px'>Company Header</div>",
        .FooterTemplate = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
    }
})

Imports Api2Pdf

Dim client = New Api2Pdf("YOUR_API_KEY")

Dim result = Await client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {
    .Html = html,
    .Options = New ChromeHtmlToPdfOptions With {
        .DisplayHeaderFooter = True,
        .HeaderTemplate = "<div style='font-size:10px'>Company Header</div>",
        .FooterTemplate = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
    }
})

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

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

IronPDF prend en charge les jetons de remplacement 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 Api2Pdf _client;

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

    [HttpGet("generate")]
    public async Task<IActionResult> GeneratePdf()
    {
        var result = await _client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest
        {
            Html = "<h1>Report</h1>"
        });

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

        // Redirect to download URL
        return Redirect(result.FileUrl);
    }
}

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

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

    [HttpGet("generate")]
    public async Task<IActionResult> GeneratePdf()
    {
        var result = await _client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest
        {
            Html = "<h1>Report</h1>"
        });

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

        // Redirect to download URL
        return Redirect(result.FileUrl);
    }
}

Imports Microsoft.AspNetCore.Mvc

<ApiController>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _client As Api2Pdf

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

    <HttpGet("generate")>
    Public Async Function GeneratePdf() As Task(Of IActionResult)
        Dim result = Await _client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {
            .Html = "<h1>Report</h1>"
        })

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

        ' Redirect to download URL
        Return Redirect(result.FileUrl)
    End Function
End Class

Imports Microsoft.AspNetCore.Mvc

<ApiController>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _client As Api2Pdf

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

    <HttpGet("generate")>
    Public Async Function GeneratePdf() As Task(Of IActionResult)
        Dim result = Await _client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {
            .Html = "<h1>Report</h1>"
        })

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

        ' Redirect to download URL
        Return Redirect(result.FileUrl)
    End Function
End Class

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.BinaryData, "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.BinaryData, "application/pdf", "report.pdf");
    }
}

Imports Microsoft.AspNetCore.Mvc

<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.BinaryData, "application/pdf", "report.pdf")
    End Function
End Class

Imports Microsoft.AspNetCore.Mvc

<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.BinaryData, "application/pdf", "report.pdf")
    End Function
End Class

IronPDF retourne 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);
}

' 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

' 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

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 result = await client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest { Html = html });

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

var result = await client.Chrome.HtmlToPdfAsync(new ChromeHtmlToPdfRequest { Html = html });

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

Imports System

Dim result = Await client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {.Html = html})

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

Imports System

Dim result = Await client.Chrome.HtmlToPdfAsync(New ChromeHtmlToPdfRequest With {.Html = html})

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

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

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

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	None	~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

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

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)

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)

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

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

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

renderer.RenderingOptions.ImageQuality = 80

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

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

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.

Veuillez noter: API2PDF et PDFSharp sont des marques déposées de leurs propriétaires respectifs. Ce site n'est pas affilié, approuvé ou sponsorisé par Api2Pdf ou empira Software GmbH. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.

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 et créer des manuels bien structurés et visuellement attrayants.

...