Die C# PDF-Bibliothek

HTML zu PDF

using IronPdf;

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

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

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

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

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

using IronPdf;

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

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

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

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

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

PM >Install-Package IronPdf

Install-Package IronPdf

VIDEOS

Wie man eingebetteten Text und Bilder aus PDFs in C# extrahiert

Curtis Chau

Updated: 19. Juli 2026

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 Api2pdfzu 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 Api2pdfin Betracht ziehen?

Während Api2pdfeine 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 eine Basisgebühr von 1 $/Monat plus gemessene Nutzung (Datenübertragung und Rechenzeit in Sekunden) auf unbestimmte Zeit, während IronPDF eine einmalige unbefristete Lizenz bietet. Aktuelle Zahlen auf api2pdf.com/pricing überprüfen:

Komponente	Api2pdf	IronPDF
Basis	1 $/Monat	Einmalige Lizenz
Bandbreite	0,001 $ pro MB	n/v (lokal)
Rechnen	0,00019551 $ pro Sekunde	n/v (lokal)
Volumenskalierung	Linear mit Nutzung und Dateigröße	Pauschal (Lite ~749 $, Plus ~1.499 $, Professional ~2.999 $)

Schwerwiegendere Workloads (große Dateien, JS-lastige Seiten, lange Renderzeiten) erhöhen die Api2pdf-Rechnung; Die Kosten für IronPDF sind nach der Lizenzierung fest.

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.

Api2pdfvs. IronPDF: Hauptunterschiede

Aspekt	Api2pdf	IronPDF
Datenverarbeitung	Übermittlung an Cloud-Server von Drittanbietern	Lokale Verarbeitung in Ihrer Infrastruktur
Preisgestaltung	1 $/Monat Grundgebühr + gemessen (0,001 $/MB Bandbreite, 0,00019551 $/Sekunde Rechnen)	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

Uninstall-Package Api2Pdf
Install-Package IronPdf

PowerShell

Schritt 2: Namensraumreferenzen aktualisieren

Ersetzen Sie die Api2pdf-Namensräume durch IronPDF:

// Remove these
using Api2Pdf;

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

// Remove these
using Api2Pdf;

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

Imports IronPdf
Imports IronPdf.Rendering

Imports IronPdf
Imports IronPdf.Rendering

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

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

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

Schritt 4: Entfernen der API-Schlüsselkonfiguration

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

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

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

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

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

Komplette API-Migrationsreferenz

Kernklassen-Zuordnung

Api2pdf-Klasse	IronPDF-Äquivalent
`Api2Pdf` (Client)	`ChromePdfRenderer`
`Api2PdfResult`	`PdfDocument`
`ChromeHtmlToPdfOptions`	`ChromePdfRenderOptions`

Methoden-Mapping

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

Zuordnung der Rendering-Optionen

Api2pdfOption	IronPDF-Option
`Landscape = true`	`RenderingOptions.PaperOrientation = Landscape`
`PreferCSSPageSize = true` / `Format`	`RenderingOptions.PaperSize = PdfPaperSize.A4`
`PrintBackground = true`	`RenderingOptions.PrintHtmlBackgrounds = true`
`MarginTop`, usw.	`RenderingOptions.MarginTop`, usw.
`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
using System;
using System.Threading.Tasks;
using Api2Pdf;

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

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

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

Imports System
Imports System.Threading.Tasks
Imports Api2Pdf

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

Imports System
Imports System.Threading.Tasks
Imports Api2Pdf

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

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

Imports System
Imports IronPdf

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

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

URL zu PDF-Konvertierung

Api2pdf-Einführung:

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

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

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

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

Imports System
Imports System.Threading.Tasks
Imports Api2Pdf

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

Imports System
Imports System.Threading.Tasks
Imports Api2Pdf

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

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

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

HTML-Datei in PDF mit Optionen

Api2pdf-Einführung:

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

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

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

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

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

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

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

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

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

Imports System
Imports System.IO
Imports IronPdf

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

IronPDF 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;

var client = new Api2Pdf("YOUR_API_KEY");

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

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

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

using Api2Pdf;

var client = new Api2Pdf("YOUR_API_KEY");

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

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

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

Imports Api2Pdf

Dim client As New Api2Pdf("YOUR_API_KEY")

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

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

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

Imports Api2Pdf

Dim client As New Api2Pdf("YOUR_API_KEY")

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

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

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

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

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

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

Passwort-geschützte PDFs

Api2pdf-Einführung:

using Api2Pdf;

var client = new Api2Pdf("YOUR_API_KEY");

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

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

using Api2Pdf;

var client = new Api2Pdf("YOUR_API_KEY");

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

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

Imports Api2Pdf

Dim client = New Api2Pdf("YOUR_API_KEY")

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

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

Imports Api2Pdf

Dim client = New Api2Pdf("YOUR_API_KEY")

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

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

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

Imports IronPdf

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

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

pdf.SaveAs("protected.pdf")

IronPDF bietet granulare Kontrolle über die PDF-Berechtigungen durch die SecuritySettings Eigenschaft.

Kopf- und Fußzeilen

Api2pdf-Einführung:

using Api2Pdf;

var client = new Api2Pdf("YOUR_API_KEY");

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

using Api2Pdf;

var client = new Api2Pdf("YOUR_API_KEY");

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

Imports Api2Pdf

Dim client = New Api2Pdf("YOUR_API_KEY")

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

Imports Api2Pdf

Dim client = New Api2Pdf("YOUR_API_KEY")

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

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

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

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

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

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

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

ASP.NET Core -Integration

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

Api2pdf-Muster:

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

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

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

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

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

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

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

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

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

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

Imports Microsoft.AspNetCore.Mvc

<ApiController>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _client As Api2Pdf

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

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

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

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

Imports Microsoft.AspNetCore.Mvc

<ApiController>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _client As Api2Pdf

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

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

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

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

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

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

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

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

        return File(pdf.BinaryData, "application/pdf", "report.pdf");
    }
}

Imports Microsoft.AspNetCore.Mvc

<ApiController>
Public Class PdfController
    Inherits ControllerBase

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

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

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

        Return File(pdf.BinaryData, "application/pdf", "report.pdf")
    End Function
End Class

Imports Microsoft.AspNetCore.Mvc

<ApiController>
Public Class PdfController
    Inherits ControllerBase

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

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

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

        Return File(pdf.BinaryData, "application/pdf", "report.pdf")
    End Function
End Class

IronPDF gibt das PDF direkt über BinaryData oder Stream zurück, und eliminiert das Umleitungs-zu-Download-Muster.

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

' Program.vb or Startup.vb
Public Sub ConfigureServices(services As IServiceCollection)
    services.AddScoped(Of IPdfService, IronPdfService)()
End Sub

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

' IronPdfService.vb
Public Class IronPdfService
    Implements IPdfService

    Private ReadOnly _renderer As ChromePdfRenderer

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

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

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

Migration der Fehlerbehandlung

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

Api2pdf-Muster:

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

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

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

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

Imports System

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

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

Imports System

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

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

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

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

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

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

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)

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)

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

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

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

renderer.RenderingOptions.ImageQuality = 80

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

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

Zusätzliche Ressourcen

Durch die Migration von Api2pdfzu 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.

Hinweis:: API2PDF und PDFSharp sind eingetragene Marken ihrer jeweiligen Eigentümer. Diese Seite ist in keiner Weise verbunden mit, unterstützt durch oder gesponsert von Api2Pdf oder empira Software GmbH. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

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 Handbücher.

...