Comment ajouter des tampons et des filigranes aux PDF en C#

Le problème du cloud uniquement

PDFBolt est une plateforme SaaS uniquement cloud exposée en tant qu'API REST ; il n'y a pas de SDK .NET officiel et pas de paquet NuGet PDFBolt. L'intégration est faite manuellement avec HttpClient contre https://api.pdfbolt.com/v1/direct. Bien qu'elle soit pratique pour des prototypes rapides, cette architecture crée des défis pour les applications de production :

1. Traitement uniquement cloud : Chaque document passe par les serveurs de PDFBolt— il n'y a pas d'option auto-hébergée, ce qui peut être un obstacle pour les équipes qui ont besoin de plus de contrôle sur le flux de données.

2. Considérations sur la confidentialité des données : Les documents sensibles (contrats, dossiers médicaux, données financières) sont transmis en externe. Les entreprises traitant des données réglementées auront des préoccupations légitimes.

3. Limites d'utilisation : Le plan gratuit est limité à 100 documents par mois, 20 requêtes par minute, 1 requête simultanée, ce qui peut ne pas suffire pour les charges de travail de production. Les niveaux payants (par pdfbolt.com/pricing) vont de 19 $/mois à 249 $/mois.

4. Dépendance réseau : Les pannes Internet ou les temps d'arrêt de PDFBoltsignifient que votre génération de PDF s'arrête entièrement.

5. Latence : L'aller-retour sur le réseau ajoute des secondes à chaque conversion par rapport au traitement local.

6. Examen de conformité : Les audits GDPR, HIPAA et SOC2 nécessitent généralement une documentation supplémentaire lorsque le traitement de documents externes est impliqué.

7. Sécurité des clés API : Les fuites de clés API peuvent entraîner une utilisation non autorisée facturée sur votre compte.

8. Enfermement par le vendeur : Votre application s'arrête si PDFBoltchange les termes ou ferme.

Comparaison de PDFBoltet IronPDF

IronPDF fournit une base auto-hébergée sur la plateforme .NET moderne qui garde le traitement des documents local et élimine la dépendance à un service cloud externe.

Prérequis

1. Environnement .NET : .NET Framework 4.6.2+ ou .NET Core 3.1+ / .NET 5/6/7/8/9+
2. Accès à NuGet : possibilité d'installer des packages NuGet
3. Licence IronPDF : Obtenez votre clé de licence sur IronPDF

Modifications du paquet NuGet

PDFBolt n'a pas de SDK .NET officiel et pas de paquet NuGet PDFBolt, donc il n'y a rien à désinstaller. Le nettoyage du côté de PDFBoltconsiste à supprimer le wrapper HttpClient fait à la main et les DTO de requête/réponse. Ensuite, installez IronPDF:

# Install IronPDF(replaces the hand-rolled HttpClient wrapper)
dotnet add package IronPdf

# Install IronPDF(replaces the hand-rolled HttpClient wrapper)
dotnet add package IronPdf

Configuration de la licence

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Identifier l'utilisation de PDFBolt

# Find all PDFBoltREST calls
grep -rE "api\.pdfbolt\.com|API-KEY|/v1/direct" --include="*.cs" .

# Find API key references
grep -r "PDFBOLT\|ApiKey" --include="*.cs" --include="*.json" --include="*.config" .

# Find all PDFBoltREST calls
grep -rE "api\.pdfbolt\.com|API-KEY|/v1/direct" --include="*.cs" .

# Find API key references
grep -r "PDFBOLT\|ApiKey" --include="*.cs" --include="*.json" --include="*.config" .

Correspondances de concepts de base

Mappages de méthodes de conversion

Mappages de méthodes de sortie

Mappages de configuration de page

Mappages des espaces réservés de l'en-tête et du pied de page

Exemple 1 : HTML de base vers PDF

Before (PDFBolt — REST via HttpClient):

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim payload As String = JsonSerializer.Serialize(New With {
            .html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html))
        })

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Après (IronPDF):

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

La différence structurelle est le modèle d'intégration. PDFBoltvous oblige à encoder en base64 le HTML, à construire une charge utile JSON, à définir l'en-tête API-KEY, POST vers https://api.pdfbolt.com/v1/direct, à attendre la réponse et à écrire vous-même les octets retournés sur le disque.

L'ChromePdfRenderer.RenderHtmlAsPdf() d'IronPDF renvoie un objet PdfDocument avec une méthode SaveAs() intégrée. Le modèle orienté objet vous permet de manipuler le PDF (ajouter des filigranes, fusionner des documents, appliquer la sécurité) avant de l'enregistrer. Si vous avez besoin des octets bruts pour la compatibilité avec le code existant, utilisez pdf.BinaryData. Voir la documentation HTML vers PDF pour des options de rendu supplémentaires.

Exemple 2 : Conversion d'une URL en PDF

Before (PDFBolt — REST via HttpClient):

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var payload = JsonSerializer.Serialize(new { url = "https://www.example.com" });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
    }
}

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/quick-start-guide/csharp
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var payload = JsonSerializer.Serialize(new { url = "https://www.example.com" });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("webpage.pdf", pdfBytes);
    }
}

Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim payload = JsonSerializer.Serialize(New With {.url = "https://www.example.com"})

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes As Byte() = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("webpage.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Après (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

Du côté de PDFBolt, la conversion d'URL nécessite toujours un aller-retour complet REST : créer le corps JSON, définir l'entête de clé API, attendre le POST, et écrire les octets de réponse. Bien que vous pointiez déjà vers une URL publique, l'extraction et le rendu se produisent tous deux sur les serveurs de PDFBolt.

L'RenderUrlAsPdf() d'IronPDF renvoie un PdfDocument avec la méthode SaveAs() intégrée. L'avantage clé est qu'IronPDF effectue l'extraction URL et le rendu PDF localement — aucune donnée de document ne quitte votre infrastructure. En savoir plus sur la conversion d'URL en PDF.

Exemple 3 : Fichier HTML avec paramètres de page personnalisés

Before (PDFBolt — REST via HttpClient):

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/parameters
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = await File.ReadAllTextAsync("input.html");
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            format = "A4",
            margin = new { top = "20mm", bottom = "20mm" },
            printBackground = true
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

// REST API — no official .NET SDK; integrate via HttpClient.
// Docs: https://pdfbolt.com/docs/parameters
using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = await File.ReadAllTextAsync("input.html");
        var payload = JsonSerializer.Serialize(new
        {
            html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            format = "A4",
            margin = new { top = "20mm", bottom = "20mm" },
            printBackground = true
        });

        using var http = new HttpClient();
        http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
        using var content = new StringContent(payload, Encoding.UTF8, "application/json");
        using var response = await http.PostAsync("https://api.pdfbolt.com/v1/direct", content);
        response.EnsureSuccessStatusCode();

        var pdfBytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("output.pdf", pdfBytes);
    }
}

Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Text
Imports System.Text.Json
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html = Await File.ReadAllTextAsync("input.html")
        Dim payload = JsonSerializer.Serialize(New With {
            .html = Convert.ToBase64String(Encoding.UTF8.GetBytes(html)),
            .format = "A4",
            .margin = New With {.top = "20mm", .bottom = "20mm"},
            .printBackground = True
        })

        Using http As New HttpClient()
            http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
            Using content As New StringContent(payload, Encoding.UTF8, "application/json")
                Using response As HttpResponseMessage = Await http.PostAsync("https://api.pdfbolt.com/v1/direct", content)
                    response.EnsureSuccessStatusCode()

                    Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
                    Await File.WriteAllBytesAsync("output.pdf", pdfBytes)
                End Using
            End Using
        End Using
    End Function
End Module

Après (IronPDF):

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        var html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        Dim html = File.ReadAllText("input.html")
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Cet exemple montre la correspondance de configuration de page. PDFBoltaccepte des format de haut niveau plus un objet imbriqué margin dont les valeurs sont des chaînes style CSS ("20mm").IronPDF utilise un objet RenderingOptions sur le rendu avec des propriétés fortement typées.

Les principales correspondances :

• "format": "A4" → PdfPaperSize.A4 (énumération fortement typée)
• "margin": { "top": "20mm" } → RenderingOptions.MarginTop = 20 (mm numériques)

Les marges d'IronPDF sont toujours en millimètres numériques, donc les chaînes d'unités CSS de PDFBoltcomme "20mm" se mappent directement. L'espace de noms IronPdf.Rendering est requis pour accéder à l'énumération PdfPaperSize. Pour des configurations de page supplémentaires, voir la documentation des options de rendu.

Changement de type de retour

Le point de terminaison /v1/direct de PDFBoltrenvoie le PDF brut comme le corps de réponse HTTP ;IronPDF renvoie un PdfDocument :

// PDFBoltpattern:
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("output.pdf", pdfBytes);

//IronPDF pattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;

// PDFBoltpattern:
var pdfBytes = await response.Content.ReadAsByteArrayAsync();
await File.WriteAllBytesAsync("output.pdf", pdfBytes);

//IronPDF pattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;

Imports System.IO
Imports System.Net.Http

' PDFBoltpattern:
Dim pdfBytes = Await response.Content.ReadAsByteArrayAsync()
Await File.WriteAllBytesAsync("output.pdf", pdfBytes)

' IronPDF pattern:
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

' Or if you need bytes:
Dim pdfBytes As Byte() = renderer.RenderHtmlAsPdf(html).BinaryData

Changement de modèle d'intégration

La forme d'intégration change du client REST vers une bibliothèque en processus :

// PDFBolt
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
// ... build JSON, POST to https://api.pdfbolt.com/v1/direct

// IronPDF
var renderer = new ChromePdfRenderer();

// PDFBolt
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY");
// ... build JSON, POST to https://api.pdfbolt.com/v1/direct

// IronPDF
var renderer = new ChromePdfRenderer();

Imports System.Net.Http

' PDFBolt
Using http As New HttpClient()
    http.DefaultRequestHeaders.Add("API-KEY", "YOUR-PDFBOLT-API-KEY")
    ' ... build JSON, POST to https://api.pdfbolt.com/v1/direct
End Using

' IronPDF
Dim renderer As New ChromePdfRenderer()

Modification du modèle de configuration

La configuration de PDFBoltest des champs JSON sur le corps de la requête ;IronPDF utilise RenderingOptions :

// PDFBolt: JSON request fields
new { format = "A4", margin = new { top = "20mm" } }

// IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;

// PDFBolt: JSON request fields
new { format = "A4", margin = new { top = "20mm" } }

// IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;

' PDFBolt: JSON request fields
New With {Key .format = "A4", Key .margin = New With {Key .top = "20mm"}}

' IronPDF: RenderingOptions properties
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20

Élimination des clés API

PDFBolt nécessite un en-tête API-KEY sur chaque requête ;IronPDF utilise une clé de licence unique :

// PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config["PDFBolt:ApiKey"]);

// IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();

// PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config["PDFBolt:ApiKey"]);

// IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
var renderer = new ChromePdfRenderer();

' PDFBolt: API key per HTTP call (security risk if leaked)
http.DefaultRequestHeaders.Add("API-KEY", config("PDFBolt:ApiKey"))

' IronPDF: License key once at startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim renderer As New ChromePdfRenderer()

Supprimer la gestion des erreurs réseau

Le traitement local signifie qu'il n'y a pas d'erreurs de réseau à gérer :

// PDFBolt: Network error handling required
catch (HttpRequestException ex)
catch (TaskCanceledException)
catch (TimeoutException)

// IronPDF: Remove network-specific catches entirely

// PDFBolt: Network error handling required
catch (HttpRequestException ex)
catch (TaskCanceledException)
catch (TimeoutException)

// IronPDF: Remove network-specific catches entirely

Nouvelles fonctionnalités disponibles

Après la migration vers IronPDF, vous gagnez des capacités que PDFBoltne fournit pas :

// PDF Merging (not available in PDFBolt)
var merged = PdfDocument.Merge(pdf1, pdf2);

// Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>");

// Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret";

// Text Extraction (not available in PDFBolt)
string text = pdf.ExtractAllText();

// PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png");

// PDF Merging (not available in PDFBolt)
var merged = PdfDocument.Merge(pdf1, pdf2);

// Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>");

// Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret";

// Text Extraction (not available in PDFBolt)
string text = pdf.ExtractAllText();

// PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png");

' PDF Merging (not available in PDFBolt)
Dim merged = PdfDocument.Merge(pdf1, pdf2)

' Watermarks (not available in PDFBolt)
pdf.ApplyWatermark("<h1 style='opacity:0.3;'>DRAFT</h1>")

' Password Protection (not available in PDFBolt)
pdf.SecuritySettings.UserPassword = "secret"

' Text Extraction (not available in PDFBolt)
Dim text As String = pdf.ExtractAllText()

' PDF to Images (not available in PDFBolt)
pdf.RasterizeToImageFiles("page_*.png")

Problème 1 : Pas de paquet PDFBolt sur NuGet

Problème : Recherche de using PDFBolt; / new HtmlToPdfConverter() dans IronPDF.

Solution : PDFBoltn'a pas de SDK .NET — son intégration est HttpClient contre https://api.pdfbolt.com/v1/direct.IronPDF remplace entièrement ce wrapper par ChromePdfRenderer :

// IronPDF
var renderer = new ChromePdfRenderer();

// IronPDF
var renderer = new ChromePdfRenderer();

' IronPDF
Dim renderer As New ChromePdfRenderer()

Problème 2 : Où est allé ConvertHtmlString ?

Problème : Migration d'un wrapper PDFBoltinterne qui exposait une méthode ConvertHtmlString(html).

Solution: Use RenderHtmlAsPdf():

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);

// IronPDF
var pdf = renderer.RenderHtmlAsPdf(html);

Problème 3 : Où est allé ConvertUrl ?

Problème : Migration d'un wrapper PDFBoltinterne qui exposait une méthode ConvertUrl(url).

Solution: Use RenderUrlAsPdf():

// IronPDF
var pdf = renderer.RenderUrlAsPdf(url);

// IronPDF
var pdf = renderer.RenderUrlAsPdf(url);

Problème 4 : Champ JSON format → Enum

Problème : Traduction du champ JSON "format": "A4" de PDFBolt.

Solution : Utilisez PdfPaperSize de IronPdf.Rendering :

// IronPDF
using IronPdf.Rendering;
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

// IronPDF
using IronPdf.Rendering;
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

Imports IronPdf.Rendering

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

Edition 5 : La première génération de PDF est lente

Problème : Le rendu initial prend plus de temps que prévu.

Solution : Le moteur Chromium s'initialise lors de sa première utilisation. Préchauffez si nécessaire :

// Warm up during application startup
var renderer = new ChromePdfRenderer();
renderer.RenderHtmlAsPdf("<html><body></body></html>");

// Warm up during application startup
var renderer = new ChromePdfRenderer();
renderer.RenderHtmlAsPdf("<html><body></body></html>");

' Warm up during application startup
Dim renderer As New ChromePdfRenderer()
renderer.RenderHtmlAsPdf("<html><body></body></html>")

Pré-migration

• Inventorier tous les appels REST PDFBoltdans la base de code (api.pdfbolt.com)
• Documenter les champs de requête JSON actuels (format, margin, printBackground, headerTemplate, etc.)
• Identifier le code de gestion des clés API à supprimer
• Listez 429 / gestion de relance de quota à supprimer
• Obtenir une clé de licence IronPDF

Modifications du paquet

• Supprimer le wrapper et les DTO PDFBoltHttpClient faits à la main (aucun paquet NuGet à désinstaller)
• Installer le paquet NuGet IronPdf : dotnet add package IronPdf
• Ajouter l'espace de noms using IronPdf;
• Ajouter using IronPdf.Rendering; pour les énumérations de taille de papier

Modifications du code

• Ajouter la configuration de la clé de licence au démarrage
• Remplacer l'intégration HttpClient + API-KEY par ChromePdfRenderer
• Remplacer POST /v1/direct par RenderHtmlAsPdf() / RenderUrlAsPdf()
• Remplacer await response.Content.ReadAsByteArrayAsync() + File.WriteAllBytes() par pdf.SaveAs() (ou pdf.BinaryData si des octets sont encore nécessaires)
• Mapper les champs JSON "format" / "margin" vers RenderingOptions.PaperSize / RenderingOptions.MarginTop etc.
• Supprimer le code de gestion des clés API
• Supprimez la gestion des limites de taux 429
• Supprimer la gestion des erreurs réseau

Après la migration

• Supprimer la clé API des fichiers de configuration
• Supprimer la clé API des gestionnaires de secrets
• Exécutez tous les tests comparant la sortie PDF
• Vérifiez que les dimensions et les marges des pages s'affichent correctement.
• Envisagez d'ajouter de nouvelles fonctionnalités (filigranes, sécurité, fusion).