Wie man Stempel & Wasserzeichen in PDFs in C# hinzufügt

Das Cloud-Only-Problem

PDFBolt ist eine ausschließlich cloudbasierte SaaS-Plattform, die als REST-API bereitgestellt wird; es gibt kein offizielles .NET SDK und kein PDFBolt NuGet-Paket. Die Integration erfolgt manuell mit HttpClient gegen https://api.pdfbolt.com/v1/direct. Obwohl bequem für schnelle Prototypen, schafft diese Architektur Herausforderungen für produktionsreife Anwendungen:

1. Nur-Cloud-Verarbeitung: Jedes Dokument durchläuft die Server von PDFBolt- es gibt keine selbst gehostete Option, was ein Hindernis für Teams sein kann, die mehr Kontrolle über den Datenfluss benötigen.

2. Datenschutzüberlegungen: Sensible Dokumente (Verträge, Krankenakten, finanzielle Daten) werden extern übertragen. Unternehmen, die mit regulierten Daten arbeiten, haben berechtigte Prüfungsbedenken.

3. Nutzungsgrenzen: Das kostenlose Tier ist auf 100 Dokumente pro Monat, 20 Anfragen pro Minute, 1 gleichzeitige Anfrage beschränkt, was für produktionsreife Workloads möglicherweise nicht ausreicht. Bezahlte Stufen (laut pdfbolt.com/preise) skalieren von $19/Monat bis $249/Monat.

4. Netzwerkabhängigkeit: Internetausfälle oder PDFBolt-Ausfallzeiten bedeuten, dass Ihre PDF-Erzeugung vollständig stoppt.

5. Latenz: Die Netzwerk-Roundtrip-Zeit verlängert jede Konvertierung um Sekunden im Vergleich zur lokalen Verarbeitung.

6. Compliance-Prüfung: GDPR-, HIPAA- und SOC2-Audits erfordern in der Regel zusätzliche Dokumentation, wenn externe Dokumentenverarbeitung beteiligt ist.

7. Sicherheit der API-Schlüssel: Durchgesickerte API-Schlüssel können zu unautorisierter Nutzung führen, die Ihrem Konto in Rechnung gestellt wird.

8. Vendor Lock-in: Ihre Anwendung funktioniert nicht mehr, wenn PDFBoltdie Bedingungen ändert oder eingestellt wird.

PDFBoltvs IronPDF Vergleich

IronPDF bietet eine selbst gehostete Grundlage auf moderner .NET, die die Dokumentenverarbeitung lokal hält und die Abhängigkeit von einem externen Cloud-Service entfernt.

Voraussetzungen

1. .NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
2. NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
3. IronPDF -Lizenz: Ihren Lizenzschlüssel erhalten Sie unter IronPDF.

NuGet-Paketänderungen

PDFBolt hat kein offizielles .NET SDK und kein PDFBolt NuGet-Paket, daher gibt es nichts zu deinstallieren. Die Bereinigung auf der PDFBolt-Seite besteht darin, den manuell erstellten HttpClient Wrapper und die Anfragen-/Antwort-DTOs zu löschen. Dann IronPDF installieren:

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

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

Lizenz-Konfiguration

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

Die Verwendung von PDFBolterkennen

# 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" .

Kernkonzept-Zuordnungen

Konvertierungsmethoden-Zuordnungen

Zuordnungen von Ausgabemethoden

Zuordnungen der Seitenkonfiguration

Kopf-/Fußzeilen-Platzhalter-Zuordnungen

Beispiel 1: Grundlegendes HTML zu PDF

Vorher (PDFBolt - REST über 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

Nach (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

Der strukturelle Unterschied ist das Integrationsmodell. PDFBolterfordert, dass Sie das HTML base64-kodieren, eine JSON-Nutzlast erstellen, den API-KEY Header setzen, POST auf https://api.pdfbolt.com/v1/direct, auf die Antwort warten und die zurückgegebenen Bytes selbst auf die Festplatte schreiben.

IronPDF's ChromePdfRenderer.RenderHtmlAsPdf() gibt ein PdfDocument Objekt mit einer integrierten SaveAs() Methode zurück. Das objektorientierte Modell erlaubt es Ihnen, das PDF zu manipulieren (Wasserzeichen hinzufügen, Dokumente zusammenführen, Sicherheit anwenden), bevor Sie es speichern. Wenn Sie die Roh-Bytes für die Kompatibilität mit vorhandenem Code benötigen, verwenden Sie pdf.BinaryData. Weitere Rendering-Optionen finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Konvertierung von URL in PDF

Vorher (PDFBolt - REST über 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

Nach (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

Auf der PDFBolt-Seite erfordert die URL-Konvertierung immer noch die vollständige REST-Rundreise: Erstellen Sie den JSON-Körper, setzen Sie den API-Schlüssel-Header, warten Sie auf den POST und schreiben Sie die Antwort-Bytes. Auch wenn Sie bereits auf eine öffentliche URL zeigen, erfolgen das Abrufen und Rendern auf den Servern von PDFBolt.

IronPDF's RenderUrlAsPdf() gibt ein PdfDocument zurück mit der integrierten SaveAs() Methode. Der Hauptvorteil besteht darin, dass IronPDF das URL-Abrufen und PDF-Rendern lokal durchführt - keine Dokumentendaten verlassen Ihre Infrastruktur. Erfahren Sie mehr über die URL in PDF Konvertierung.

Beispiel 3: HTML-Datei mit benutzerdefinierten Seiteneinstellungen

Vorher (PDFBolt - REST über 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

Nach (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

Dieses Beispiel zeigt die Seitenkonfigurationszuordnung. PDFBoltakzeptiert Top-Level format plus ein verschachteltes margin Objekt, dessen Werte CSS-ähnliche Zeichenfolgen ("20mm") sind.IronPDF verwendet ein RenderingOptions Objekt auf dem Renderer mit stark typisierten Eigenschaften.

Die wichtigsten Mappings:

• "format": "A4" → PdfPaperSize.A4 (stark typisiertes Enum)
• "margin": { "top": "20mm" } → RenderingOptions.MarginTop = 20 (numerisch mm)

IronPDF-Ränder sind immer numerische Millimeter, daher werden PDFBoltCSS-Einheiten wie "20mm" direkt zugeordnet. Das IronPdf.Rendering Namespace ist erforderlich, um auf das PdfPaperSize Enum zuzugreifen. Für zusätzliche Seitenkonfigurationen, siehe die Rendering-Optionen-Dokumentation.

Rückgabetyp ändern

PDFBolt's /v1/direct Endpoint gibt das rohe PDF als HTTP-Antwort zurück;IronPDF gibt ein PdfDocument zurück:

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

Integrationsmodelländerung

Die Integrationsform ändert sich vom REST-Client zur In-Prozess-Bibliothek:

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

Änderung von Konfigurationsmustern

PDFBolt-Konfiguration sind JSON-Felder im Anforderungskörper;IronPDF verwendet 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

API-Schlüssel-Eliminierung

PDFBolt erfordert einen API-KEY Header bei jeder Anfrage;IronPDF verwendet einen einmaligen Lizenzschlüssel:

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

Entfernen der Netzwerk-Fehlerbehandlung

Lokale Verarbeitung bedeutet, dass keine Netzwerkfehler zu behandeln sind:

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

Neue Funktionen verfügbar

Nach der Migration zu IronPDF erhalten Sie Fähigkeiten, die PDFBoltnicht bietet:

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

Problem 1: Kein PDFBolt Paket auf NuGet

Problem: Nach using PDFBolt; / new HtmlToPdfConverter() in IronPDF suchen.

Lösung: PDFBolthat kein .NET SDK — die Integration erfolgt mit HttpClient gegen https://api.pdfbolt.com/v1/direct.IronPDF ersetzt diesen Wrapper vollständig durch ChromePdfRenderer:

// IronPDF
var renderer = new ChromePdfRenderer();

// IronPDF
var renderer = new ChromePdfRenderer();

' IronPDF
Dim renderer As New ChromePdfRenderer()

Problem 2: Wo ist ConvertHtmlString hin?

Problem: Eine interne PDFBolt-Wrap-Unterstützung migrieren, die eine ConvertHtmlString(html) Methode bereitstellte.

Lösung: Verwenden Sie RenderHtmlAsPdf():

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

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

Problem 3: Wo ist ConvertUrl hin?

Problem: Eine interne PDFBolt-Wrap-Unterstützung migrieren, die eine ConvertUrl(url) Methode bereitstellte.

Lösung: Verwenden Sie RenderUrlAsPdf():

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

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

Issue 4: format JSON Field → Enum

Problem: Das JSON-Feld "format": "A4" von PDFBoltübersetzen.

Lösung: Verwenden Sie PdfPaperSize von 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

Ausgabe 5: Erste PDF-Erzeugung ist langsam

Problem: Das erste Rendern dauert länger als erwartet.

Lösung: Die Chromium-Engine initialisiert sich bei der ersten Verwendung. Bei Bedarf vorwärmen:

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

Vor der Migration

• Alle PDFBoltREST-Aufrufe im Codebestand inventarisieren (api.pdfbolt.com)
• Aktuelle JSON-Anforderungsfelder dokumentieren (format, margin, printBackground, headerTemplate, usw.)
• API-Schlüsselverwaltungscode identifizieren, der entfernt werden soll
• Listen Sie die 429 / Kontingent-Wiederholungsbehandlung auf, die gelöscht werden soll -IronPDF-Lizenzschlüssel erhalten

Paketänderungen

• Den manuell erstellten PDFBoltHttpClient Wrapper und DTOs löschen (kein NuGet-Paket zum Deinstallieren)
• IronPdf NuGet-Paket installieren: dotnet add package IronPdf
• using IronPdf; Namespace hinzufügen
• using IronPdf.Rendering; für Papiergrößen-Enums hinzufügen

Code-Änderungen

• Lizenzschlüsselkonfiguration beim Start hinzufügen
• Die HttpClient + API-KEY Integration durch ChromePdfRenderer ersetzen
• POST /v1/direct mit RenderHtmlAsPdf() / RenderUrlAsPdf() ersetzen
• await response.Content.ReadAsByteArrayAsync() + File.WriteAllBytes() durch pdf.SaveAs() ersetzen (oder pdf.BinaryData, wenn noch Bytes benötigt werden)
• "format" / "margin" JSON-Felder zu RenderingOptions.PaperSize / RenderingOptions.MarginTop usw. zuordnen.
• API-Schlüsselverwaltungscode entfernen
• Entfernen Sie 429 / Ratenlimitbehandlung
• Netzwerkfehlerbehandlung entfernen

Nach der Migration

• API-Schlüssel aus Konfigurationsdateien löschen
• API-Schlüssel aus Secret Managern entfernen
• Führen Sie alle Tests durch und vergleichen Sie die PDF-Ausgabe.
• Überprüfen Sie, ob Seitengrößen und Ränder korrekt dargestellt werden.
• Erwägen Sie die Hinzufügung neuer Funktionen (Wasserzeichen, Sicherheit, Zusammenführung)