Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. migrati von api2pdfon zu IronPDF
MIGRATIONSLEITFäDEN

Wie man von Api2pdf zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

Api2pdf bietet einen Cloud-basierten Dienst zur PDF-Erstellung. Das Senden sensibler Dokumente an externe Server birgt jedoch Sicherheitsrisiken, Compliance-Probleme und laufende Kosten, die sich mit der Zeit summieren können. Dieser Leitfaden beschreibt detailliert die Migration von Api2pdf zu IronPDF– einer nativen .NET PDF-Bibliothek, die Dokumente vollständig auf Ihrer eigenen Infrastruktur verarbeitet. Dadurch entfallen Bedenken hinsichtlich der Datenübertragung, und die Kosten pro Konvertierung werden zu einer einmaligen Investition.

Warum einen Wechsel von Api2pdf in Betracht ziehen?

Während Api2pdf eine komfortable cloudbasierte PDF-Generierung bietet, veranlassen verschiedene Faktoren Entwicklungsteams dazu, nach lokalen Alternativen für ihre PDF-Generierungsanforderungen zu suchen.

Sicherheits- und Compliance-Bedenken

Api2pdf arbeitet als Cloud-basierter Dienst, bei dem Ihr sensibles HTML und Ihre Dokumente zur Verarbeitung an Server von Drittanbietern gesendet werden. Dies ist für Unternehmen, die mit regulierten Daten arbeiten, von großer Bedeutung.

Risiko Api2pdf IronPDF
Datenübertragung Alle Inhalte werden an externe Server gesendet Lokale Prozesse in Ihrer Infrastruktur
GDPR-Konformität Daten sind länderübergreifend Daten verlassen nie Ihre Umgebung
HIPAA-Konformität Extern übermittelte PHI PHI bleibt innerhalb Ihrer Systeme
SOC 2 Abhängigkeit von Drittanbietern Volle Kontrolle über die Datenverarbeitung
PCI DSS Potenziell offengelegte Kartendaten Keine externe Übertragung

Kostenakkumulation im Laufe der Zeit

Api2pdf berechnet ca. $0,005 pro Konvertierung auf unbestimmte Zeit, während IronPDF eine einmalige unbefristete Lizenz anbietet. Bei Anwendungen, die ein erhebliches PDF-Volumen generieren, wird der Kostenunterschied beträchtlich:

Volumen Api2pdf(jährlich) IronPDF(einmalig)
10.000 PDFs/Monat ~$600/Jahr $749 (Lite)
50.000 PDFs/Monat ~$3.000/Jahr $749 (Lite)
100.000 PDFs/Monat ~$6.000/Jahr $1,499 (Plus)

IronPDF macht sich für die meisten Produktionsanwendungen innerhalb weniger Monate bezahlt.

Leistung und Verfügbarkeit

Api2pdf erfordert Netzwerk-Roundtrips, die bei jeder PDF-Generierungsanforderung eine zusätzliche Latenz von 2-5 Sekunden verursachen.IronPDF verarbeitet lokal in 100-500 Millisekunden. Darüber hinaus funktioniert IronPDF vollständig offline und in abgeschotteten Umgebungen - wichtig für Anwendungen, die nicht von der Verfügbarkeit externer Dienste abhängig sind.

Api2pdf vs. IronPDF: Hauptunterschiede

Aspekt Api2pdf IronPDF
Datenverarbeitung Übermittlung an Cloud-Server von Drittanbietern Lokale Verarbeitung in Ihrer Infrastruktur
Preisgestaltung Bezahlung pro Konvertierung (~$0,005/PDF) Einmalige unbefristete Lizenz
Latenzzeit 2-5 Sekunden (Netzwerk-Roundtrip) 100-500ms (lokale Verarbeitung)
Offline Nicht verfügbar Arbeitet vollständig offline
Installation API-Schlüssel + HTTP-Client Einfaches NuGet-Paket
Konformität GDPR/HIPAA-Bedenken (Daten verlassen das Netzwerk) Vollständige Kontrolle der Konformität

Schritt-für-Schritt-Migrationsprozess

Schritt 1: NuGet-Pakete aktualisieren

Entfernen Sie das Api2pdf-Paket und installieren Sie 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

Oder über die Paketmanager-Konsole:

Uninstall-Package Api2Pdf
Install-Package IronPdf

Schritt 2: Namensraumreferenzen aktualisieren

Ersetzen Sie die Api2pdf-Namensräume durch IronPDF:

// Remove these
using Api2Pdf;
using Api2Pdf.DotNet;

// Add these
using IronPdf;
using IronPdf.Rendering;
// Remove these
using Api2Pdf;
using Api2Pdf.DotNet;

// Add these
using IronPdf;
using IronPdf.Rendering;
Imports IronPdf
Imports IronPdf.Rendering
$vbLabelText   $csharpLabel

Schritt 3: Konfigurieren des Lizenzschlüssels

Legen Sie den IronPDF-Lizenzschlüssel beim Starten der Anwendung fest:

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

// Or configure via appsettings.json:
// { "IronPdf.LicenseKey": "YOUR-IRONPDF-LICENSE-KEY" }
// Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";

// Or configure via appsettings.json:
// { "IronPdf.LicenseKey": "YOUR-IRONPDF-LICENSE-KEY" }
' Set once at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY"

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

Schritt 4: Entfernen der API-Schlüsselkonfiguration

IronPDF läuft lokal und benötigt keine API-Schlüssel:

// Remove this Api2pdf pattern
var client = new Api2PdfClient("API_KEY");

// Just create the renderer directly
var renderer = new ChromePdfRenderer();
// Remove this Api2pdf pattern
var client = new Api2PdfClient("API_KEY");

// Just create the renderer directly
var renderer = new ChromePdfRenderer();
' Remove this Api2pdf pattern
Dim client = New Api2PdfClient("API_KEY")

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

Komplette API-Migrationsreferenz

Kernklassen-Zuordnung

Api2pdf-Klasse IronPDF-Äquivalent
Api2PdfClient ChromePdfRenderer
Api2PdfResult PdfDocument
HeadlessChromeOptions ChromePdfRenderOptions

Methoden-Mapping

Api2pdf-Methode IronPDF-Methode
client.HeadlessChrome.FromHtmlAsync(html) renderer.RenderHtmlAsPdf(html)
client.HeadlessChrome.FromUrlAsync(url) renderer.RenderUrlAsPdf(url)
response.Pdf (URL) pdf.SaveAs(path)
response.Pdf (Download) pdf.BinaryData
client.PdfSharp.MergePdfsAsync(urls) PdfDocument.Merge(pdfs)
client.PdfSharp.SetPasswordAsync(url, pwd) pdf.SecuritySettings.OwnerPassword

Zuordnung der Rendering-Optionen

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

Beispiele für die Code-Migration

HTML-zu-PDF-Konvertierung

Die am häufigsten verwendete Api2pdf-Operation verdeutlicht den grundlegenden Shift– von Cloud-API-Aufrufen hin zur lokalen Verarbeitung.

Api2pdf-Einführung:

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

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        var apiResponse = await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Hello World</h1>");
        Console.WriteLine(apiResponse.Pdf);
    }
}
// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.Threading.Tasks;
using Api2Pdf.DotNet;

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        var apiResponse = await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Hello World</h1>");
        Console.WriteLine(apiResponse.Pdf);
    }
}
Imports System
Imports System.Threading.Tasks
Imports Api2Pdf.DotNet

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

IronPDF-Implementierung:

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

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
Imports System
Imports IronPdf

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

IronPDF eliminiert den Netzwerk-Roundtrip, die API-Schlüsselverwaltung und den separaten Download-Schritt, der durch das URL-basierte Antwortmuster von Api2pdf erforderlich ist.

URL zu PDF-Konvertierung

Api2pdf-Einführung:

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

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        var apiResponse = await a2pClient.HeadlessChrome.FromUrlAsync("https://www.example.com");
        Console.WriteLine(apiResponse.Pdf);
    }
}
// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.Threading.Tasks;
using Api2Pdf.DotNet;

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        var apiResponse = await a2pClient.HeadlessChrome.FromUrlAsync("https://www.example.com");
        Console.WriteLine(apiResponse.Pdf);
    }
}
Imports System
Imports System.Threading.Tasks
Imports Api2Pdf.DotNet

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

IronPDF-Implementierung:

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

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF created from URL successfully");
    }
}
// NuGet: Install-Package IronPdf
using System;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF created from URL successfully");
    }
}
Imports System
Imports IronPdf

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

HTML-Datei in PDF mit Optionen

Api2pdf-Einführung:

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

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        string html = File.ReadAllText("input.html");
        var options = new HeadlessChromeOptions
        {
            Landscape = true,
            PrintBackground = true
        };
        var apiResponse = await a2pClient.HeadlessChrome.FromHtmlAsync(html, options);
        Console.WriteLine(apiResponse.Pdf);
    }
}
// NuGet: Install-Package Api2Pdf.DotNet
using System;
using System.IO;
using System.Threading.Tasks;
using Api2Pdf.DotNet;

class Program
{
    static async Task Main(string[] args)
    {
        var a2pClient = new Api2PdfClient("your-api-key");
        string html = File.ReadAllText("input.html");
        var options = new HeadlessChromeOptions
        {
            Landscape = true,
            PrintBackground = true
        };
        var apiResponse = await a2pClient.HeadlessChrome.FromHtmlAsync(html, options);
        Console.WriteLine(apiResponse.Pdf);
    }
}
no response after 91 seconds
$vbLabelText   $csharpLabel

IronPDF-Implementierung:

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

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
        string html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created with options successfully");
    }
}
// NuGet: Install-Package IronPdf
using System;
using System.IO;
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
        string html = File.ReadAllText("input.html");
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created with options successfully");
    }
}
Imports System
Imports System.IO
Imports IronPdf

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

IronPDF konfiguriert die Rendering-Optionen direkt am Renderer-Objekt, anstatt sie als separate Optionsparameter an jeden API-Aufruf zu übergeben.

Mehrere PDFs zusammenführen

Api2pdf-Einführung:

using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

var pdfUrls = new List<string>
{
    "https://example.com/pdf1.pdf",
    "https://example.com/pdf2.pdf",
    "https://example.com/pdf3.pdf"
};

var request = new PdfMergeRequest { Urls = pdfUrls };
var response = await a2pClient.PdfSharp.MergePdfsAsync(request);

if (response.Success)
{
    // Download merged PDF from response.Pdf URL
}
using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

var pdfUrls = new List<string>
{
    "https://example.com/pdf1.pdf",
    "https://example.com/pdf2.pdf",
    "https://example.com/pdf3.pdf"
};

var request = new PdfMergeRequest { Urls = pdfUrls };
var response = await a2pClient.PdfSharp.MergePdfsAsync(request);

if (response.Success)
{
    // Download merged PDF from response.Pdf URL
}
Imports Api2Pdf.DotNet

Dim a2pClient = New Api2PdfClient("YOUR_API_KEY")

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

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

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

IronPDF-Implementierung:

using IronPdf;

// Load PDFs from files
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var pdf3 = PdfDocument.FromFile("document3.pdf");

// Merge all PDFs
var merged = PdfDocument.Merge(pdf1, pdf2, pdf3);
merged.SaveAs("merged.pdf");
using IronPdf;

// Load PDFs from files
var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var pdf3 = PdfDocument.FromFile("document3.pdf");

// Merge all PDFs
var merged = PdfDocument.Merge(pdf1, pdf2, pdf3);
merged.SaveAs("merged.pdf");
Imports IronPdf

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

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

Die statische Methode Merge von IronPDF akzeptiert mehrere Dokumente direkt und eliminiert so den URL-basierten Workflow.

Passwort-geschützte PDFs

Api2pdf-Einführung:

using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

// Generate PDF first
var pdfResponse = await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Confidential</h1>");

// Then add password protection in separate call
var protectedResponse = await a2pClient.PdfSharp.SetPasswordAsync(
    pdfResponse.Pdf,
    "secretpassword"
);
using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

// Generate PDF first
var pdfResponse = await a2pClient.HeadlessChrome.FromHtmlAsync("<h1>Confidential</h1>");

// Then add password protection in separate call
var protectedResponse = await a2pClient.PdfSharp.SetPasswordAsync(
    pdfResponse.Pdf,
    "secretpassword"
);
Imports Api2Pdf.DotNet

Dim a2pClient = New Api2PdfClient("YOUR_API_KEY")

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

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

IronPDF-Implementierung:

using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

// Set security in one step
pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

pdf.SaveAs("protected.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

// Set security in one step
pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;

pdf.SaveAs("protected.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>")

' Set security in one step
pdf.SecuritySettings.OwnerPassword = "owner123"
pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit

pdf.SaveAs("protected.pdf")
$vbLabelText   $csharpLabel

IronPDF ermöglicht die detaillierte Kontrolle über PDF-Berechtigungen über die Eigenschaft SecuritySettings.

Kopf- und Fußzeilen

Api2pdf-Einführung:

using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

var options = new HeadlessChromeOptions
{
    HeaderHtml = "<div style='font-size:10px'>Company Header</div>",
    FooterHtml = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
};

var response = await a2pClient.HeadlessChrome.FromHtmlAsync(html, options);
using Api2Pdf.DotNet;

var a2pClient = new Api2PdfClient("YOUR_API_KEY");

var options = new HeadlessChromeOptions
{
    HeaderHtml = "<div style='font-size:10px'>Company Header</div>",
    FooterHtml = "<div style='font-size:10px'>Page <span class='pageNumber'></span></div>"
};

var response = await a2pClient.HeadlessChrome.FromHtmlAsync(html, options);
Imports Api2Pdf.DotNet

Dim a2pClient = New Api2PdfClient("YOUR_API_KEY")

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

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

IronPDF-Implementierung:

using IronPdf;

var renderer = new ChromePdfRenderer();

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

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

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("with-headers.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

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

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

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("with-headers.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

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

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

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

IronPDF unterstützt Platzhalter-Tokens wie {page} und {total-pages} für die dynamische Seitennummerierung. Weitere Optionen finden Sie in der Kopf- und Fußzeilen-Dokumentation.

ASP.NET Core -Integration

Das asynchrone HTTP-Muster von Api2pdf unterscheidet sich deutlich von der direkten PDF-Erzeugung von IronPDF.

Api2pdf-Muster:

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

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

    [HttpGet("generate")]
    public async Task<IActionResult> GeneratePdf()
    {
        var response = await _client.HeadlessChrome.FromHtmlAsync("<h1>Report</h1>");

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

        // Redirect to download URL
        return Redirect(response.Pdf);
    }
}
[ApiController]
public class PdfController : ControllerBase
{
    private readonly Api2PdfClient _client;

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

    [HttpGet("generate")]
    public async Task<IActionResult> GeneratePdf()
    {
        var response = await _client.HeadlessChrome.FromHtmlAsync("<h1>Report</h1>");

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

        // Redirect to download URL
        return Redirect(response.Pdf);
    }
}
Imports Microsoft.AspNetCore.Mvc

<ApiController>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _client As Api2PdfClient

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

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

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

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

IronPDF-Muster:

[ApiController]
public class PdfController : ControllerBase
{
    [HttpGet("generate")]
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>");

        // Return PDF directly - no download step needed
        return File(pdf.BinaryData, "application/pdf", "report.pdf");
    }

    [HttpGet("generate-async")]
    public async Task<IActionResult> GeneratePdfAsync()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Report</h1>");

        return File(pdf.Stream, "application/pdf", "report.pdf");
    }
}
[ApiController]
public class PdfController : ControllerBase
{
    [HttpGet("generate")]
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Report</h1>");

        // Return PDF directly - no download step needed
        return File(pdf.BinaryData, "application/pdf", "report.pdf");
    }

    [HttpGet("generate-async")]
    public async Task<IActionResult> GeneratePdfAsync()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Report</h1>");

        return File(pdf.Stream, "application/pdf", "report.pdf");
    }
}
Imports Microsoft.AspNetCore.Mvc
Imports System.Threading.Tasks

<ApiController>
Public Class PdfController
    Inherits ControllerBase

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

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

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

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

IronPDF gibt die PDF-Datei direkt über BinaryData oder Stream zurück, wodurch das Weiterleitungsmuster zum Herunterladen entfällt.

Dependency Injection Konfiguration

// Program.cs or Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IPdfService, IronPdfService>();
}

// IPdfService.cs
public interface IPdfService
{
    PdfDocument GenerateFromHtml(string html);
    Task<PdfDocument> GenerateFromHtmlAsync(string html);
}

// IronPdfService.cs
public class IronPdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;

    public IronPdfService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    }

    public PdfDocument GenerateFromHtml(string html) =>
        _renderer.RenderHtmlAsPdf(html);

    public Task<PdfDocument> GenerateFromHtmlAsync(string html) =>
        _renderer.RenderHtmlAsPdfAsync(html);
}
// Program.cs or Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IPdfService, IronPdfService>();
}

// IPdfService.cs
public interface IPdfService
{
    PdfDocument GenerateFromHtml(string html);
    Task<PdfDocument> GenerateFromHtmlAsync(string html);
}

// IronPdfService.cs
public class IronPdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;

    public IronPdfService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        _renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    }

    public PdfDocument GenerateFromHtml(string html) =>
        _renderer.RenderHtmlAsPdf(html);

    public Task<PdfDocument> GenerateFromHtmlAsync(string html) =>
        _renderer.RenderHtmlAsPdfAsync(html);
}
' Program.vb or Startup.vb
Public Sub ConfigureServices(services As IServiceCollection)
    services.AddScoped(Of IPdfService, IronPdfService)()
End Sub

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

' IronPdfService.vb
Public Class IronPdfService
    Implements IPdfService

    Private ReadOnly _renderer As ChromePdfRenderer

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

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

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

Migration der Fehlerbehandlung

Api2pdf verwendet Antwortobjektprüfungen.IronPDF verwendet die Standardausnahmen von .NET.

Api2pdf-Muster:

var response = await a2pClient.HeadlessChrome.FromHtmlAsync(html);

if (!response.Success)
{
    Console.WriteLine($"Error: {response.Error}");
    return;
}
var response = await a2pClient.HeadlessChrome.FromHtmlAsync(html);

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

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

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

IronPDF-Muster:

try
{
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (IronPdf.Exceptions.IronPdfLicenseException ex)
{
    Console.WriteLine($"License error: {ex.Message}");
}
catch (IronPdf.Exceptions.IronPdfRenderingException ex)
{
    Console.WriteLine($"Rendering error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
try
{
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (IronPdf.Exceptions.IronPdfLicenseException ex)
{
    Console.WriteLine($"License error: {ex.Message}");
}
catch (IronPdf.Exceptions.IronPdfRenderingException ex)
{
    Console.WriteLine($"Rendering error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
Imports IronPdf.Exceptions

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

Leistungsvergleich

Metrik Api2pdf IronPDF
Einfaches HTML 2-5 Sekunden (Netzwerk) 100-500ms (lokal)
Komplexe Seite 5-10 Sekunden 500ms-2s
Batch von 100 Minuten (Tarifgrenzen) Sekunden (parallel)
Offline Nicht verfügbar Arbeitet vollständig
Kaltstart Keine ~2s (erstes Rendern)

Tipps zur Optimierung der Leistung

// 1. Reuse renderer instance
private static readonly ChromePdfRenderer SharedRenderer = new ChromePdfRenderer();

public PdfDocument GeneratePdf(string html)
{
    return SharedRenderer.RenderHtmlAsPdf(html);
}

// 2. Parallel generation
var tasks = htmlDocs.Select(html =>
    Task.Run(() => SharedRenderer.RenderHtmlAsPdf(html)));
var results = await Task.WhenAll(tasks);

// 3. Disable unnecessary features for speed
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = false; // If not needed
renderer.RenderingOptions.WaitFor.RenderDelay(0);   // No delay
// 1. Reuse renderer instance
private static readonly ChromePdfRenderer SharedRenderer = new ChromePdfRenderer();

public PdfDocument GeneratePdf(string html)
{
    return SharedRenderer.RenderHtmlAsPdf(html);
}

// 2. Parallel generation
var tasks = htmlDocs.Select(html =>
    Task.Run(() => SharedRenderer.RenderHtmlAsPdf(html)));
var results = await Task.WhenAll(tasks);

// 3. Disable unnecessary features for speed
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = false; // If not needed
renderer.RenderingOptions.WaitFor.RenderDelay(0);   // No delay
Imports System.Threading.Tasks

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

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

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

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

Fehlerbehebung bei allgemeinen Migrationsproblemen

Ausgabe: PDF sieht anders aus als die Api2pdf-Ausgabe

Anpassung an die Headless Chrome-Einstellungen von Api2pdf:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
renderer.RenderingOptions.ViewPortWidth = 1280;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
renderer.RenderingOptions.ViewPortWidth = 1280;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.PrintHtmlBackgrounds = True
renderer.RenderingOptions.ViewPortWidth = 1280
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1000)
$vbLabelText   $csharpLabel

Problem: Externe Ressourcen werden nicht geladen

Konfigurieren Sie Zeitüberschreitungen beim Laden von Ressourcen:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.AllFontsLoaded(timeout: 10000);
renderer.RenderingOptions.WaitFor.NetworkIdle(timeout: 10000);

// Or use base URL for relative paths
var pdf = renderer.RenderHtmlAsPdf(html, baseUrl: "https://example.com/");
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.AllFontsLoaded(timeout: 10000);
renderer.RenderingOptions.WaitFor.NetworkIdle(timeout: 10000);

// Or use base URL for relative paths
var pdf = renderer.RenderHtmlAsPdf(html, baseUrl: "https://example.com/");
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.AllFontsLoaded(timeout:=10000)
renderer.RenderingOptions.WaitFor.NetworkIdle(timeout:=10000)

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

Problem: Große PDF-Dateigrößen

Komprimieren Sie Bilder nach der Erstellung:

renderer.RenderingOptions.ImageQuality = 80;

// Or compress after generation
pdf.CompressImages(quality: 75);
pdf.SaveAs("compressed.pdf");
renderer.RenderingOptions.ImageQuality = 80;

// Or compress after generation
pdf.CompressImages(quality: 75);
pdf.SaveAs("compressed.pdf");
renderer.RenderingOptions.ImageQuality = 80

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

Post-Migrations-Checkliste

Überprüfen Sie nach Abschluss der Codemigration Folgendes:

  • Überprüfung der PDF-Ausgabequalität auf Übereinstimmung mit den Erwartungen
  • Alle Grenzfälle testen (große Dokumente, Sonderzeichen)
  • Leistungskennzahlen validieren (sollte eine deutliche Verbesserung aufweisen)
  • Docker-Konfigurationen gegebenenfalls aktualisieren
  • Entfernen Sie das Api2pdf-Portalkonto und die API-Schlüssel.
  • Update-Überwachung (keine API-Latenzverfolgung mehr erforderlich)
  • Neue Muster für Ihr Team dokumentieren
  • CI/CD-Pipelines aktualisieren

Zukunftssicherheit für Ihre PDF-Infrastruktur

Da sich .NET 10 nähert und C# 14 neue Sprachfunktionen einführt, gewährleistet die Wahl einer nativen .NET-PDF-Bibliothek die Kompatibilität mit den sich entwickelnden Laufzeitfunktionen. IronPDF s Engagement für die Unterstützung der neuesten .NET-Versionen bedeutet, dass sich Ihre Migrationsinvestition auszahlt, wenn Projekte bis ins Jahr 2025 und 2026 reichen - ohne dass laufende Kosten pro Konvertierung anfallen.

Zusätzliche Ressourcen

Durch die Migration von Api2pdf zu IronPDF wird Ihre PDF-Erstellung von einem Cloud-abhängigen Kostenmodell pro Konvertierung zu einer lokalen, einmaligen Investition. Ihre sensiblen Dokumente verbleiben in Ihrer Infrastruktur, die Latenzzeit sinkt von Sekunden auf Millisekunden, und Sie sind bei dieser wichtigen Anwendungsfunktion nicht mehr vom Hersteller abhängig.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an