Wie man HTML zu PDF in Rust konvertiert
Die Umwandlung von HTML-Dateien oder rohen HTML-Strings in PDF ist eine häufige Anforderung für Rechnungen, Berichte und Quittungen. Rust verfügt über keine eingebaute Rendering-Engine dafür, und eine zu schreiben ist kein realistisches Nebenprojekt. Das Parsen von HTML ist der einfache Teil. Das Parsen von CSS, Layout und Paginierung sind die Bereiche, in denen die Arbeit nie endet, weshalb ein Browser eine natürliche Wahl für die PDF-Erstellung in Rust ist. Dieses Tutorial wandelt HTML in Rust mit dem Open-Source-headless_chrome-Crate in PDF um, das Chrome das Rendering überlässt und das fertige PDF an Ihr Rust-Programm zurückgibt.
Headless Chrome Crate für Rust
headless_chrome ist ein MIT-lizenziertes Rust-Crate, das einen Chrome- oder Chromium-Browser über das Chrome DevTools Protocol steuert. Es kann Seiten öffnen, Elemente anklicken, Screenshots machen und die integrierte Druck-zu-PDF-Funktion von Chrome aufrufen. Da die Seite von einem echten Browser gerendert wird, funktionieren CSS-Layouts, Webfonts und JavaScript genauso wie in Chrome.
Chrome kann eine Seite auch direkt über die Kommandozeile mit --print-to-pdf drucken. Das ist nur ein CLI-Aufruf, daher landen die Bytes auf der Festplatte statt in Ihrem Programm, und die verfügbaren Druckeinstellungen sind begrenzt. Die Steuerung des DevTools Protocols hingegen hält die Bytes in Ihrem Programm und überlässt das gesamte Web-Layout dem Browser. Es ist dasselbe Protokoll, auf dem die entsprechenden Bibliotheken in anderen Sprachen basieren. Das Crate wird von der Rust-Community gepflegt, daher erfolgt der Support über den GitHub-Issue-Tracker.
Voraussetzungen
Um einen HTML-zu-PDF-Konverter in Rust zu erstellen, stellen Sie sicher, dass folgende Voraussetzungen erfüllt sind:
- Rust 1.85 oder neuer. Installieren Sie das Rust-Toolchain mit rustup. Unter Windows benötigt das MSVC-Toolchain zusätzlich eine Visual Studio-Installation, da
rustcdessen Linker und Bibliotheken verwendet. - Google Chrome, Chromium oder Microsoft Edge installiert.
headless_chromesucht nach dem Browser imPATH, in derCHROME-Umgebungsvariable und unter Windows in der Registry, wobei Edge als Fallback dient. - Grundkenntnisse in Rust und Cargo.
Dieses Tutorial wurde mit Rust 1.98.1, headless_chrome 1.0.22 und Chrome 153 unter Windows 11 getestet. Der gleiche Code läuft auch unter Linux und macOS.
Erstellen eines Rust HTML-zu-PDF-Projekts mit Cargo
Erstellen Sie das Binärprojekt und fügen Sie beide Abhängigkeiten über ein Terminal hinzu:
cargo new html_to_pdf
cd html_to_pdf
cargo add headless_chrome urlencoding
Schritt 3 verwendet das urlencoding-Crate, um den HTML-String als Data-URL an Chrome zu übergeben.

Überprüfung von Cargo.toml
Nach dem Ausführen von cargo add erscheinen beide Crates unter [dependencies] in der Datei Cargo.toml:
[package]
name = "html_to_pdf"
version = "0.1.0"
edition = "2024"
[dependencies]
headless_chrome = "1.0.22"
urlencoding = "2.1.3"

Das Standard-offline-Feature des Crates verwendet einen bereits installierten Browser. Falls auf dem Zielsystem kein Chrome vorhanden ist, aktivieren Sie stattdessen das fetch-Feature (cargo add headless_chrome --features fetch), und das Crate kann einen Chromium-Build für Sie herunterladen.
Schritte zur Umwandlung von HTML in PDF in Rust
Schritt 1: Importieren der Crates
Öffnen Sie src/main.rs und ersetzen Sie den Inhalt durch die Importe, die das Programm benötigt. Browser und LaunchOptions starten Chrome, und PrintToPdfOptions steuert die PDF-Ausgabe:
use std::fs;
use headless_chrome::types::PrintToPdfOptions;
use headless_chrome::{Browser, LaunchOptions};
Schritt 2: Starten von Headless Chrome
Starten Sie als Nächstes einen Headless-Browser und öffnen Sie einen Tab. main gibt ein Result zurück, sodass jeder Aufruf den ?-Operator anstelle von unwrap verwenden kann:
fn main() -> Result<(), Box<dyn std::error::Error>> {
// Launch a headless Chrome instance
let browser = Browser::new(LaunchOptions {
headless: true,
..Default::default()
})?;
// Open a new tab to load the HTML into
let tab = browser.new_tab()?;
Browser::default() liefert dasselbe Ergebnis mit weniger Code. LaunchOptions wird hier gezeigt, weil Sie dort die Fenstergröße, den Chrome-Pfad oder das Sandbox-Flag setzen können, wenn Sie diese benötigen.
Schritt 3: Setzen des HTML-Inhalts
Geben Sie nun das HTML an, das zum PDF werden soll. Die Rust-Rohstring-Syntax r#"..."# hält die Anführungszeichen im HTML lesbar:
let html = r#"
<html>
<head>
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
h1 { color: #2a5db0; }
table { border-collapse: collapse; width: 100%; }
th, td { border: 1px solid #ccc; padding: 8px; text-align: left; }
th { background-color: #f0f4fa; }
</style>
</head>
<body>
<h1>Hello, World!</h1>
<p>This PDF was generated from an HTML string in Rust.</p>
<table>
<tr><th>Item</th><th>Quantity</th><th>Price</th></tr>
<tr><td>Widget</td><td>2</td><td>$10.00</td></tr>
<tr><td>Gadget</td><td>1</td><td>$25.00</td></tr>
</table>
</body>
</html>
"#;
// Load the HTML string as a data URL and wait for the page to finish loading
let data_url = format!("data:text/html;charset=utf-8,{}", urlencoding::encode(html));
tab.navigate_to(&data_url)?.wait_until_navigated()?;
print_to_pdf hat keine HTML-Option. Es druckt, was auch immer der Tab anzeigt, und das Crate hat keine Methode, um den Seiteninhalt direkt zu setzen, daher wird der HTML-String als data:-URL prozentkodiert und der Tab navigiert dorthin.
wait_until_navigated blockiert dann, bis die Seite bereit ist, und stoppt nicht beim Ladeereignis. Das Crate aktiviert die Lebenszyklusereignisse von Chrome und setzt das Navigations-Flag bei networkAlmostIdle zurück, dem Browser-Lebenszyklus-Meilenstein, der erreicht wird, sobald die von der Seite geladenen Anfragen (Netzwerk-Leerlauf) abgeklungen sind. Zu dem Zeitpunkt, an dem der Tab die Navigation als abgeschlossen meldet, sind in der Regel auch späte Webfonts und Bilder geladen.
Schritt 4: HTML in PDF umwandeln
Nachdem die Seite geladen wurde, rufen Sie print_to_pdf auf. PrintToPdfOptions entspricht Chromes Druckeinstellungen, und jedes Feld ist optional:
// Print the page to PDF with background colors and 0.4 inch margins
let options = PrintToPdfOptions {
print_background: Some(true),
margin_top: Some(0.4),
margin_bottom: Some(0.4),
margin_left: Some(0.4),
margin_right: Some(0.4),
..Default::default()
};
Ränder und Papiergrößen werden in Zoll angegeben. Ohne paper_width und paper_height verwendet Chrome US Letter (8,5 x 11 Zoll). Chrome druckt keine Hintergrundfarben oder -bilder, es sei denn, Sie fordern dies explizit an. print_background ist standardmäßig deaktiviert, und ohne diese Option wird die Schattierung des Tabellenkopfes im PDF weggelassen.
Die Felder für die Seiteneinrichtung (landscape, scale, page_ranges und die Header- und Footer-Templates) erhalten später in diesem Tutorial einen eigenen Abschnitt.
Schritt 5: Ausgabe als Byte-Vektor erhalten
print_to_pdf gibt das fertige Dokument als Vec<u8> im Speicher zurück. Es wird noch nichts auf die Festplatte geschrieben, sodass die Bytes in eine Datei, einen HTTP-Response-Body oder einen Cloud-Speicher geschrieben werden können:
let pdf_data: Vec<u8> = tab.print_to_pdf(Some(options))?;
Schritt 6: Die PDF-Datei speichern
Um das PDF zu speichern, schreiben Sie den Byte-Vektor mit std::fs::write in eine Datei. Dieser Befehl erstellt die Datei, schreibt alle Bytes und schließt sie in einem Aufruf:
// Write the PDF bytes to disk
fs::write("output.pdf", &pdf_data)?;
println!("PDF saved successfully ({} bytes).", pdf_data.len());
Ok(())
}
Schritt 7: Aufräumen
Im Gegensatz zur wkhtmltopdf C-API gibt es keine destroy- oder deinit-Funktionen, die aufgerufen werden müssen. Wenn browser am Ende von main aus dem Gültigkeitsbereich fällt, beendet seine Drop-Implementierung den Chrome-Prozess und entfernt den temporären Profilordner, den es erstellt hat. Wenn ein Schritt fehlschlägt und ? vorzeitig zurückkehrt, wird die gleiche Bereinigung dennoch ausgeführt.
In einem lang laufenden Dienst sollten Sie eine Browser-Instanz am Leben halten und für jedes Dokument einen neuen Tab öffnen, anstatt für jede Anfrage einen neuen Chrome-Prozess zu starten.
Schritt 8: Code ausführen und PDF-Datei generieren
Bauen und führen Sie das Projekt aus dem Projektordner aus:
cargo run
Der erste Build kompiliert 143 Crates, was auf dem hier verwendeten Rechner 45 Sekunden dauerte. Das Programm gibt dann die Größe der generierten Datei aus:

Die Datei output.pdf wird im Projektordner gespeichert. Die CSS-Styles, einschließlich der Header-Farbe sowie der Tabellenrahmen und des Hintergrunds, bleiben erhalten:

Hier ist das generierte output.pdf selbst:
Eine URL oder HTML-Datei in Rust in PDF umwandeln
Die gleichen navigate_to- und print_to_pdf-Aufrufe funktionieren für Webseiten und lokale HTML-Dateien. Für lokale Dateien fügen Sie das url-Crate mit cargo add url hinzu, damit Sie den Dateipfad auf jedem Betriebssystem in eine gültige file://-URL umwandeln können.
Das folgende Beispiel liest eine lokale Vorlage, speichern Sie diese also neben Cargo.toml als invoice.html:
<html>
<head>
<style>
body { font-family: Arial, sans-serif; margin: 30px; }
.box { background: #2a5db0; color: #fff; padding: 16px; }
</style>
</head>
<body>
<div class="box"><h2>Invoice #1024</h2></div>
<p>Loaded from a local HTML file.</p>
</body>
</html>
Speichern Sie das folgende Programm als examples/url_and_file.rs und führen Sie es mit cargo run --example url_and_file aus:
use std::fs;
use headless_chrome::types::PrintToPdfOptions;
use headless_chrome::Browser;
use url::Url;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let browser = Browser::default()?;
let tab = browser.new_tab()?;
// Convert a live web page to PDF
tab.navigate_to("https://doc.rust-lang.org/book/")?
.wait_until_navigated()?;
let url_pdf = tab.print_to_pdf(None)?;
fs::write("url.pdf", url_pdf)?;
// Convert a local HTML file to PDF
let path = fs::canonicalize("invoice.html")?;
let file_url = Url::from_file_path(&path).map_err(|_| "invalid file path")?;
tab.navigate_to(file_url.as_str())?.wait_until_navigated()?;
let options = PrintToPdfOptions {
landscape: Some(true),
print_background: Some(true),
..Default::default()
};
fs::write("invoice.pdf", tab.print_to_pdf(Some(options))?)?;
println!("Saved url.pdf and invoice.pdf");
Ok(())
}
Ein Tab verarbeitet beide Dokumente nacheinander. Die URL wird mit Chromes Standardeinstellungen gedruckt, und die lokale Rechnung wird im Querformat mit ihren Hintergrundfarben ausgegeben:

Die Webseite wurde in url.pdf gespeichert:
Und die lokale HTML-Datei wurde im Querformat in invoice.pdf ausgegeben:
Speichern Sie Vorlagen mit einer .html-Endung, da Chrome anhand der Eingabeerweiterung entscheidet, wie eine lokale Datei behandelt wird. Das gleiche Markup, als .txt gespeichert, wurde als sichtbare Tags statt als gerenderte Seite ausgegeben.
Seitengröße, Seitenzahlen und Seitenumbrüche
PrintToPdfOptions spiegelt Chromes Druckdialog wider, und die unterstützten Werte sind die, die der Dialog selbst anbietet. landscape: Some(true) schaltet in den Querformatmodus, scale nimmt einen Zoomfaktor, wobei 1.0 die volle Größe ist, und page_ranges nimmt einen einsbasierten String wie "1-5, 8, 11-13".
Seitenzahlen können von beiden Seiten kommen. Geben Sie Chrome eine Footer-Vorlage, und es ersetzt pageNumber und totalPages auf jeder Seite:
let options = PrintToPdfOptions {
display_header_footer: Some(true),
header_template: Some("<span></span>".into()),
footer_template: Some(
"<div style='font-size:10px;width:100%;text-align:center'>Page <span class='pageNumber'></span> of <span class='totalPages'></span></div>".into()),
margin_bottom: Some(0.6),
..Default::default()
};
Der CSS-Weg funktioniert ebenfalls. Chrome Platform Status listet @page-Margin-Boxen ab Meilenstein 131, daher ist eine ältere Anleitung historisches Verhalten. Unter Chrome 153 nummerierte diese Seitenzähler-Regel allein jede Seite eines vierseitigen Dokuments:
@page { @bottom-center { content: "Page " counter(page); } }
Auch die Steuerung, wo ein Seitenumbruch erfolgt, ist gewöhnliches CSS. Ein Testdokument mit sechs Karten zeigte den Unterschied. Ohne die Eigenschaft endete die erste Seite mitten in der dritten Karte, und der Rest dieser Karte wurde auf Seite zwei fortgesetzt. Durch Hinzufügen der CSS-Eigenschaft break-inside wurde jede Karte vollständig auf die nächste Seite verschoben, zwei pro Seite, ohne dass eine geteilt wurde:
.card { break-inside: avoid; }
Was Chrome in die PDF einfügt
Zwei Optionen verändern die Struktur der Datei, nicht das Aussehen der Seite:
let options = PrintToPdfOptions {
generate_document_outline: Some(true),
generate_tagged_pdf: Some(true),
..Default::default()
};
generate_document_outline wandelt Ihre Überschriften in PDF-Lesezeichen um. Ein Bericht mit einer h1- und zwei h2-Überschriften erzeugte mit dieser Option eine Dokumentenübersicht mit drei Einträgen, und ohne diese Option überhaupt keine Übersicht.
generate_tagged_pdf fordert eine getaggte PDF-Datei an, die Struktur, die Screenreader und PDF/UA-Prüfer lesen. Das DevTools-Protokoll dokumentiert den Standard als „embedder choice“ statt „aus“, und der Test hier entsprach dem. Auch wenn beide Optionen deaktiviert sind, enthielt die Ausgabe weiterhin einen Strukturbaum und übernahm die Dokumentensprache aus <html lang="en">. Setzen Sie dieses Attribut in Ihren Vorlagen in jedem Fall und prüfen Sie Ihre eigene Ausgabe, bevor Sie sich auf das Flag verlassen.
Schriftarten werden mit Font-Subsetting eingebettet, sodass eine Seite, die in Georgia gesetzt wurde, AAAAAA+Georgia-Bold und BAAAAA+Georgia statt der gesamten Familie erzeugte. Ein JPEG-Foto wurde als JPEG gespeichert, nicht neu kodiert.
Headless Chrome-Nutzung in einem Rust-Service
Das Crate ist blockierend, weshalb keiner der obigen Codes als async fn main geschrieben ist. Wenn Ihr Service bereits eine asynchrone Laufzeit wie Tokio verwendet, halten Sie den Browser vom Reactor fern, indem Sie ihn innerhalb von tokio::task::spawn_blocking aufrufen, sodass ein langsames Rendering den Executor nicht blockieren kann.
Nichts wird endlos abgefragt. Jeder Tab-Vorgang läuft gegen ein Timeout und gibt im Fehlerfall einen Fehler zurück, anstatt zu hängen, sodass eine Seite, die nie fertig wird, keinen Worker blockieren kann.
Chrome-Start- und -Shutdown-Zeilen erscheinen in jedem Service, der einen Logger installiert, da das Crate über das log-Crate berichtet. Um Protokolle aus der Browser-Ebene zu entfernen, ohne Ihre eigenen zu unterdrücken, filtern Sie nach Ziel, zum Beispiel RUST_LOG=info,headless_chrome=warn.
Häufige Probleme beim Konvertieren von HTML zu PDF in Rust
Dies sind die Fehlerquellen, die in der Produktion auftreten:
- JavaScript-gerenderter Inhalt:
wait_until_navigatedgibt zurück, sobald das Netzwerk ruhig ist, was nicht dasselbe ist wie das vollständige Zeichnen eines Diagramms. Rufen Sietab.wait_for_element("#report-ready")für ein Element auf, das die Seite hinzufügt, wenn sie fertig ist, und drucken Sie dann. - Timeouts: Tab-Vorgänge laufen standardmäßig nach 20 Sekunden ab. Erhöhen Sie das Limit mit
tab.set_default_timeout(std::time::Duration::from_secs(60))für langsame Seiten. - Große HTML-Strings: Chrome begrenzt URLs auf 2 MB, und das schließt
data:-URLs ein. Für größere Dokumente schreiben Sie das HTML in eine temporäre Datei und laden es mit einerfile://-URL wie oben gezeigt. - Docker- und Linux-Container: Chromes Sandbox kann nicht gestartet werden, wenn der Prozess als root läuft, und Puppeteers Troubleshooting-Guide rät dringend davon ab, ohne Sandbox zu arbeiten. Fügen Sie dem Image einen nicht privilegierten Benutzer hinzu und lassen Sie die Sandbox aktiviert, und setzen Sie
sandbox: falseinLaunchOptionsnur, wenn Sie keine Alternative haben. In jedem Fall benötigt das Image die Systembibliotheken von Chrome. - Deployment: Jeder Server, der das Programm ausführt, benötigt einen kompatiblen Browser, sodass Chrome Teil Ihres Deployments wird, auch wenn der Rust-Code zu einer einzigen Binärdatei kompiliert.
Weitere Möglichkeiten, HTML zu PDF in Rust zu konvertieren
headless_chrome ist nicht der einzige Weg. Welche Methode passt, hängt davon ab, ob Ihre Dokumente JavaScript benötigen und wie viele Sie gleichzeitig rendern.
Chromium-basiert, wie in diesem Tutorial
html2pdf bezeichnet sich selbst als reine CLI über das headless_chrome-Crate und wird auch als Bibliothek ausgeliefert, deren API asynchron ist und auf tokio läuft, was Ihnen das Schreiben des spawn_blocking-Wrappers erspart.
Gotenberg verlagert den Browser komplett aus Ihrem Prozess. Es handelt sich um eine Docker-basierte API zur Konvertierung von Dokumenten in PDF: Chromium verarbeitet URLs, HTML und Markdown, LibreOffice übernimmt Office-Formate, und Ihr Rust-Service sendet eine Datei per HTTP und erhält ein PDF zurück. Das hält Chrome aus dem Deployment Ihrer Binärdatei heraus, kostet aber den Betrieb eines zusätzlichen Dienstes.
Browserfreie Rust-Engines
Headless Chrome kann bei gleichzeitiger PDF-Erstellung ressourcenintensiv sein, da jede Konvertierung einen eigenen Browser-Prozess und den dazugehörigen Speicher benötigt. Zwei Rust-Projekte setzen genau dort an.
htmltopdf ist eine MIT-lizenzierte Engine, die in einem Thread ohne Subprozess rendert. In der README wird sie als für hohe Parallelität und niedrigen RAM-Verbrauch gebaut beschrieben. Die README berichtet von etwa 92 MB Spitzen-RAM gegenüber etwa 846 MB für Chromiums Hauptprozess bei einem einzelnen 1,8 MB großen Dokument. Für 20 gleichzeitige Konvertierungen werden 12,75 PDF/s bei 1,25 GiB gegenüber Chromiums 1,18 PDF/s bei 9,35 GiB gemessen, getestet mit /usr/bin/time -l auf Apple Silicon. Dies sind die projektspezifischen Benchmarks mit eigenen Testdaten und wurden für diesen Artikel nicht reproduziert. Das Crate ist nicht auf crates.io, daher installiert man es aus dem Repository, und die JavaScript-Verarbeitung ist eine optionale, begrenzte Pre-Layout-Phase, kein vollständiges Engine.
Fulgur ist eine weitere HTML-zu-PDF-Engine in Rust, die auf den Browser verzichtet. Sie ist unter Apache-2.0 lizenziert und integriert Blitz für HTML-Parsing, Stilauflösung und Layout mit Krilla für die PDF-Erstellung. Fulgur unterstützt eine kuratierte Teilmenge von HTML und CSS, die Eigenschaft für Eigenschaft im CSS-Support-Dokument nachverfolgt wird, und die Feature-Liste enthält keine JavaScript-Engine. Was abgedeckt ist, ist der paginierte Bereich, einschließlich Seitenzähler, laufende Kopfzeilen, Randboxen, break-inside, getaggte PDF und Font-Subsetting. Fulgurs Rendering-Pipeline beinhaltet ein 2-Pass-Rendering für Genauigkeit, sodass Querverweise wie target-counter() aufgelöst werden, bevor das PDF geschrieben wird.
Kommerzielle Engines
Prince unterstützt CSS Paged Media für komplexe PDF-Erstellung, einschließlich @page-Regeln, Seitenrandboxen und eines vordefinierten Seitenzählers für laufende Kopf- und Fußzeilen. Prince ist kommerzielle Software, die Sie lizenzieren, kein Crate, das Sie mit Cargo hinzufügen.
Welche passt
Jahrelang galt die Faustregel, dass Rust-native HTML-zu-PDF-Optionen nur eingeschränkten CSS- und JavaScript-Support hatten, sodass reine Rust-Engines nur für einfache Dokumente geeignet waren. Die CSS-Hälfte davon ist überholt. htmltopdf listet Flexbox, Grid, Tabellen mit Rowspans und @font-face, und Fulgur deckt paginierte Medien vollständig ab. JavaScript ist weiterhin die Lücke.
Was Ihr Dokument zeichnet, entscheidet über die Wahl. Wenn ein Server das HTML rendert und das Styling per CSS erfolgt, nimmt eine browserfreie Engine Chrome samt Speicherbedarf aus Ihrer Bereitstellung. Wenn Ihre Seiten Diagramme im Browser zeichnen oder auf eigene Skripte einer Web-App angewiesen sind, behalten Sie einen Browser in der Pipeline – wie es dieses Tutorial tut.
IronPDF für Rust (Demnächst verfügbar)
IronPDF für Rust befindet sich in der Entwicklung. Die geplante Bibliothek wird PDFs aus HTML erstellen und bestehende PDFs bearbeiten – alles aus Rust-Code heraus.
Treten Sie dem IronPDF für Rust Beta-Programm bei, um frühzeitig Zugriff zu erhalten und die API mitzugestalten.
HTML-Datei zu PDF-Datei in C#
IronPDF
IronPDF HTML-zu-PDF-Konvertierungsbibliothek ist eine .NET- und .NET Core C#-Bibliothek, die PDF-Dokumente aus HTML-Inhalten generiert. Sie bringt ihre eigene Chrome-Rendering-Engine mit, sodass kein separater Browser installiert, gestartet oder beendet werden muss.
IronPDF verarbeitet mehr als nur einfache HTML-Dokumente. Es rendert komplexe Webseiten mit CSS-Styling und JavaScript und kann PDFs nach der Erstellung auch bearbeiten, zusammenführen, signieren und sichern.
Der gleiche Job mit IronPDF, eine HTML-Zeichenkette in PDF umwandeln in C#:
using IronPdf;
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
// Create PDF content from an HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// Export to a file or Stream
pdf.SaveAs("output.pdf");Imports IronPdf
' Instantiate Renderer
Private renderer = New ChromePdfRenderer()
' Create PDF content from an HTML string using C#
Private pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>")
' Export to a file or Stream
pdf.SaveAs("output.pdf")Imports IronPdf
' Instantiate Renderer
Private renderer = New ChromePdfRenderer()
' Create PDF content from an HTML string using C#
Private pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>")
' Export to a file or Stream
pdf.SaveAs("output.pdf")Die PDF-Ausgabe:

Die Schritte aus diesem Rust-Tutorial entsprechen einzelnen IronPDF-Einstellungen. Die Seiteneinrichtung wird in benutzerdefinierten Rändern und benutzerdefiniertem Papierformat behandelt, und das JavaScript-Warteproblem wird durch die WaitFor-Rendering-Verzögerungen gelöst. Die Umwandlung einer URL in PDF oder einer HTML-Datei in PDF erfordert jeweils nur einen Methodenaufruf, und Kopf- und Fußzeilen mit Seitenzahlen benötigen keine HTML-Vorlagen. Für eine vollständige Anleitung siehe das HTML-zu-PDF-Tutorial oder lesen Sie, wie die gleiche Aufgabe in HTML zu PDF in C++ funktioniert.
Sie können all dies mit einer kostenlosen Testversion der vollständigen IronPDF-Funktionalität ausprobieren. Sie läuft 30 Tage, benötigt keine Kreditkarte und funktioniert auf Live-Servern ohne Wasserzeichen während der Evaluierung. Lizenzen danach sind unbefristet, ohne wiederkehrende Gebühren, nach Entwicklern, Projekten und Standorten gestaffelt und durch eine 30-tägige Geld-zurück-Garantie abgesichert. Um loszulegen, laden Sie IronPDF herunter.
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.