Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF verwenden
  4. C# Druckformular als PDF
IRONPDF NUTZEN

C# Druckformular zu PDF mit IronPDF verwenden

Curtis Chau
Curtis Chau
Aktualisiert:

Das Drucken eines Windows Forms als PDF in C# ist mit IronPDF unkompliziert: Rendern Sie die HTML-Darstellung des Formulars mit ChromePdfRenderer, speichern Sie sie auf der Festplatte oder im Speicher und liefern Sie ein pixelgenaues PDF in nur wenigen Codezeilen.

Das Exportieren einer Windows Forms-Anwendung in das PDF-Format ist eine häufige Anforderung bei Branchensoftware. Ob Sie Dateneingabemasken archivieren, kundenorientierte Berichte aus dem Status eines Formulars generieren oder Druckvorschauen erfassen müssen, ohne den Drucker zu berühren – die Konvertierung eines C#-Formulars in PDF beseitigt Reibungsverluste im alltäglichen Arbeitsablauf. IronPDF bietet eine .NET-native API, die die Konvertierungspipeline vom HTML-Rendering bis zur endgültigen PDF-Ausgabe übernimmt, sodass Sie auf fehleranfällige GDI+-Druck-Hacks verzichten können.

Wie installiert man IronPDF?

Fügen Sie IronPDF über NuGet zu Ihrem Projekt hinzu. Öffnen Sie die Paket-Manager-Konsole und führen Sie aus:

Install-Package IronPdf
Install-Package IronPdf
SHELL

Oder verwenden Sie die .NET-CLI:

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Nach der Installation fügen Sie using IronPdf; am Anfang jeder Datei hinzu, die die API aufruft. Das Paket ist auch direkt auf NuGet verfügbar. Unter IronPDF ist ein kostenloser Testlizenzschlüssel erhältlich, mit dem Sie während der Testphase eine wasserzeichenfreie Ausgabe erhalten.

Wie konvertiert man ein Windows Formular mithilfe von HTML in ein PDF?

Die zuverlässigste Methode zum Konvertieren eines C#-Formulars in PDF besteht darin, einen HTML-Snapshot der Formulardaten zu erstellen und diesen Snapshot mit ChromePdfRenderer zu rendern. Dieser Ansatz entkoppelt die visuelle Darstellung von der GDI+-Oberfläche von WinForms und liefert so eine klare, portable Ausgabe, die in jedem PDF-Viewer identisch aussieht.

using IronPdf;

// Set your license key once at application startup
License.LicenseKey = "YOUR-LICENSE-KEY";

// Compose an HTML representation of your form data
string formHtml = $"""
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <style>
            body  {{ font-family: Arial, sans-serif; margin: 40px; color: #222; }}
            h1    {{ color: #1a4a8a; border-bottom: 2px solid #1a4a8a; padding-bottom: 8px; }}
            label {{ font-weight: bold; display: inline-block; width: 160px; }}
            .row  {{ margin: 12px 0; }}
            .box  {{ border: 1px solid #bbb; padding: 20px; border-radius: 4px; }}
        </style>
    </head>
    <body>
        <h1>Customer Registration Form</h1>
        <div class="box">
            <div class="row"><label>Full Name:</label> Jane Smith</div>
            <div class="row"><label>Email:</label> jane@example.com</div>
            <div class="row"><label>Phone:</label> +1 555-0100</div>
            <div class="row"><label>Date:</label> {DateTime.Now:yyyy-MM-dd}</div>
        </div>
    </body>
    </html>
    """;

// Render HTML to PDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize       = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop       = 20;
renderer.RenderingOptions.MarginBottom    = 20;
renderer.RenderingOptions.MarginLeft      = 25;
renderer.RenderingOptions.MarginRight     = 25;
renderer.RenderingOptions.CssMediaType    = IronPdf.Rendering.PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;

PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("CustomerForm.pdf");

Console.WriteLine($"PDF saved -- {pdf.PageCount} page(s).");
using IronPdf;

// Set your license key once at application startup
License.LicenseKey = "YOUR-LICENSE-KEY";

// Compose an HTML representation of your form data
string formHtml = $"""
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <style>
            body  {{ font-family: Arial, sans-serif; margin: 40px; color: #222; }}
            h1    {{ color: #1a4a8a; border-bottom: 2px solid #1a4a8a; padding-bottom: 8px; }}
            label {{ font-weight: bold; display: inline-block; width: 160px; }}
            .row  {{ margin: 12px 0; }}
            .box  {{ border: 1px solid #bbb; padding: 20px; border-radius: 4px; }}
        </style>
    </head>
    <body>
        <h1>Customer Registration Form</h1>
        <div class="box">
            <div class="row"><label>Full Name:</label> Jane Smith</div>
            <div class="row"><label>Email:</label> jane@example.com</div>
            <div class="row"><label>Phone:</label> +1 555-0100</div>
            <div class="row"><label>Date:</label> {DateTime.Now:yyyy-MM-dd}</div>
        </div>
    </body>
    </html>
    """;

// Render HTML to PDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize       = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop       = 20;
renderer.RenderingOptions.MarginBottom    = 20;
renderer.RenderingOptions.MarginLeft      = 25;
renderer.RenderingOptions.MarginRight     = 25;
renderer.RenderingOptions.CssMediaType    = IronPdf.Rendering.PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;

PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);
pdf.SaveAs("CustomerForm.pdf");

Console.WriteLine($"PDF saved -- {pdf.PageCount} page(s).");
Imports IronPdf

' Set your license key once at application startup
License.LicenseKey = "YOUR-LICENSE-KEY"

' Compose an HTML representation of your form data
Dim formHtml As String = $"
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset='utf-8'>
        <style>
            body  {{ font-family: Arial, sans-serif; margin: 40px; color: #222; }}
            h1    {{ color: #1a4a8a; border-bottom: 2px solid #1a4a8a; padding-bottom: 8px; }}
            label {{ font-weight: bold; display: inline-block; width: 160px; }}
            .row  {{ margin: 12px 0; }}
            .box  {{ border: 1px solid #bbb; padding: 20px; border-radius: 4px; }}
        </style>
    </head>
    <body>
        <h1>Customer Registration Form</h1>
        <div class='box'>
            <div class='row'><label>Full Name:</label> Jane Smith</div>
            <div class='row'><label>Email:</label> jane@example.com</div>
            <div class='row'><label>Phone:</label> +1 555-0100</div>
            <div class='row'><label>Date:</label> {DateTime.Now:yyyy-MM-dd}</div>
        </div>
    </body>
    </html>
    "

' Render HTML to PDF
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20
renderer.RenderingOptions.MarginLeft = 25
renderer.RenderingOptions.MarginRight = 25
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
renderer.RenderingOptions.PrintHtmlBackgrounds = True

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)
pdf.SaveAs("CustomerForm.pdf")

Console.WriteLine($"PDF saved -- {pdf.PageCount} page(s).")
$vbLabelText   $csharpLabel

Der ChromePdfRenderer steuert eine Headless-Chromium-Engine, sodass CSS-Layouts, eingebettete Schriftarten und sogar Print-Media-Queries originalgetreu gerendert werden. Ersetzen Sie die fest codierten Feldwerte durch Daten, die zur Laufzeit von den Steuerelementen Ihres Formulars gebunden werden, um einen vollständig dynamischen Ansatz zu erhalten. Die Anleitung zur Umwandlung von HTML in PDF beschreibt alle verfügbaren Rendering-Optionen im Detail.

Wie ruft man Live-Daten aus Formularsteuerelementen ab?

Anstatt den HTML-Code manuell zu schreiben, lesen Sie die Werte direkt aus Ihren WinForms-Steuerelementen und fügen Sie sie in die Vorlage ein:

using IronPdf;

// Called from a button click handler in your WinForms application
void ExportFormToPdf()
{
    // Read control values at the moment of export
    string name    = txtName.Text;
    string email   = txtEmail.Text;
    string phone   = txtPhone.Text;
    string notes   = rtbNotes.Text.Replace("\n", "<br>");

    string html = $"""
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 30px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ border: 1px solid #ccc; padding: 10px; text-align: left; }}
                th {{ background-color: #f0f4ff; }}
                h2 {{ color: #1a4a8a; }}
            </style>
        </head>
        <body>
            <h2>Form Export -- {DateTime.Now:dd MMM yyyy HH:mm}</h2>
            <table>
                <tr><th>Field</th><th>Value</th></tr>
                <tr><td>Full Name</td><td>{name}</td></tr>
                <tr><td>Email</td><td>{email}</td></tr>
                <tr><td>Phone</td><td>{phone}</td></tr>
                <tr><td>Notes</td><td>{notes}</td></tr>
            </table>
        </body>
        </html>
        """;

    var renderer = new ChromePdfRenderer();
    PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

    // Prompt the user for a save location
    using var dialog = new SaveFileDialog();
    dialog.Filter   = "PDF Files|*.pdf";
    dialog.FileName = $"FormExport_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";

    if (dialog.ShowDialog() == DialogResult.OK)
    {
        pdf.SaveAs(dialog.FileName);
        MessageBox.Show("PDF exported successfully.", "Export Complete");
    }
}
using IronPdf;

// Called from a button click handler in your WinForms application
void ExportFormToPdf()
{
    // Read control values at the moment of export
    string name    = txtName.Text;
    string email   = txtEmail.Text;
    string phone   = txtPhone.Text;
    string notes   = rtbNotes.Text.Replace("\n", "<br>");

    string html = $"""
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 30px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ border: 1px solid #ccc; padding: 10px; text-align: left; }}
                th {{ background-color: #f0f4ff; }}
                h2 {{ color: #1a4a8a; }}
            </style>
        </head>
        <body>
            <h2>Form Export -- {DateTime.Now:dd MMM yyyy HH:mm}</h2>
            <table>
                <tr><th>Field</th><th>Value</th></tr>
                <tr><td>Full Name</td><td>{name}</td></tr>
                <tr><td>Email</td><td>{email}</td></tr>
                <tr><td>Phone</td><td>{phone}</td></tr>
                <tr><td>Notes</td><td>{notes}</td></tr>
            </table>
        </body>
        </html>
        """;

    var renderer = new ChromePdfRenderer();
    PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

    // Prompt the user for a save location
    using var dialog = new SaveFileDialog();
    dialog.Filter   = "PDF Files|*.pdf";
    dialog.FileName = $"FormExport_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";

    if (dialog.ShowDialog() == DialogResult.OK)
    {
        pdf.SaveAs(dialog.FileName);
        MessageBox.Show("PDF exported successfully.", "Export Complete");
    }
}
Imports IronPdf

' Called from a button click handler in your WinForms application
Sub ExportFormToPdf()
    ' Read control values at the moment of export
    Dim name As String = txtName.Text
    Dim email As String = txtEmail.Text
    Dim phone As String = txtPhone.Text
    Dim notes As String = rtbNotes.Text.Replace(vbLf, "<br>")

    Dim html As String = $"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 30px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ border: 1px solid #ccc; padding: 10px; text-align: left; }}
                th {{ background-color: #f0f4ff; }}
                h2 {{ color: #1a4a8a; }}
            </style>
        </head>
        <body>
            <h2>Form Export -- {DateTime.Now:dd MMM yyyy HH:mm}</h2>
            <table>
                <tr><th>Field</th><th>Value</th></tr>
                <tr><td>Full Name</td><td>{name}</td></tr>
                <tr><td>Email</td><td>{email}</td></tr>
                <tr><td>Phone</td><td>{phone}</td></tr>
                <tr><td>Notes</td><td>{notes}</td></tr>
            </table>
        </body>
        </html>
        "

    Dim renderer As New ChromePdfRenderer()
    Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)

    ' Prompt the user for a save location
    Using dialog As New SaveFileDialog()
        dialog.Filter = "PDF Files|*.pdf"
        dialog.FileName = $"FormExport_{DateTime.Now:yyyyMMdd_HHmmss}.pdf"

        If dialog.ShowDialog() = DialogResult.OK Then
            pdf.SaveAs(dialog.FileName)
            MessageBox.Show("PDF exported successfully.", "Export Complete")
        End If
    End Using
End Sub
$vbLabelText   $csharpLabel

Dieser Code-Ausschnitt behandelt den Formularexport wie einen kleinen Berichtsauftrag: Feldwerte erfassen, in eine HTML-Vorlage einbetten, rendern und dann dort speichern, wo der Benutzer es auswählt. Sie können die HTML-Tabelle um so viele Felder erweitern, wie das Formular enthält. Bei Formularen mit mehreren Registerkarten erstellen Sie separate <section> Blöcke pro Registerkarte und lassen IronPDF die Seitennummerierung automatisch durchführen.

Wie fügt man Kopf- und Fußzeilen hinzu?

Kopf- und Fußzeilen verleihen einem Formularexport den letzten Schliff für den Professional Einsatz. Die IronPDF-Klasse TextHeaderFooter fügt Text am oberen und unteren Rand jeder Seite ein, ohne den HTML-Code des Hauptteils zu verändern:

using IronPdf;
using IronPdf.Rendering;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Stamp header and footer on every page
pdf.AddTextHeaders(new TextHeaderFooter
{
    CenterText      = "Confidential -- Internal Use Only",
    LeftText        = "{date}",
    RightText       = "Page {page} of {total-pages}",
    FontSize        = 9,
    DrawDividerLine = true
});

pdf.AddTextFooters(new TextHeaderFooter
{
    CenterText = "Generated by MyApp v2.0",
    FontSize   = 8
});

pdf.SaveAs("FormWithHeader.pdf");
using IronPdf;
using IronPdf.Rendering;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Stamp header and footer on every page
pdf.AddTextHeaders(new TextHeaderFooter
{
    CenterText      = "Confidential -- Internal Use Only",
    LeftText        = "{date}",
    RightText       = "Page {page} of {total-pages}",
    FontSize        = 9,
    DrawDividerLine = true
});

pdf.AddTextFooters(new TextHeaderFooter
{
    CenterText = "Generated by MyApp v2.0",
    FontSize   = 8
});

pdf.SaveAs("FormWithHeader.pdf");
Imports IronPdf
Imports IronPdf.Rendering

Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Stamp header and footer on every page
pdf.AddTextHeaders(New TextHeaderFooter With {
    .CenterText = "Confidential -- Internal Use Only",
    .LeftText = "{date}",
    .RightText = "Page {page} of {total-pages}",
    .FontSize = 9,
    .DrawDividerLine = True
})

pdf.AddTextFooters(New TextHeaderFooter With {
    .CenterText = "Generated by MyApp v2.0",
    .FontSize = 8
})

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

Dynamische Platzhalter wie {page}, {total-pages} und {date} werden beim Rendern automatisch aufgelöst. Für eine markenspezifische Ausgabe ersetzen Sie TextHeaderFooter durch HtmlHeaderFooter und geben Sie den vollständigen HTML-Code inklusive Firmenlogos an. Die Anleitung zur Gestaltung von Kopf- und Fußzeilen zeigt alle verfügbaren Platzhalter und Layoutoptionen.

Wie konvertiert man ein Formular in ein Byte-Array anstatt in eine Datei?

Das direkte Speichern auf der Festplatte ist zwar praktisch, aber viele Anwendungen müssen die PDF-Datei über HTTP übertragen, in einer Datenbank speichern oder an einen nachgelagerten Dienst weitergeben. In diesen Fällen sollte man die Datei überspringen und direkt mit den Rohdaten arbeiten.

using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Get raw bytes -- no file required
byte[] pdfBytes = pdf.BinaryData;

// Alternatively, get a MemoryStream for APIs that accept streams
using System.IO.MemoryStream stream = pdf.Stream;
byte[] fromStream = stream.ToArray();

Console.WriteLine($"PDF size in memory: {pdfBytes.Length:N0} bytes");

// Example: return as HTTP response in ASP.NET Core
// return File(pdfBytes, "application/pdf", "form-export.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Get raw bytes -- no file required
byte[] pdfBytes = pdf.BinaryData;

// Alternatively, get a MemoryStream for APIs that accept streams
using System.IO.MemoryStream stream = pdf.Stream;
byte[] fromStream = stream.ToArray();

Console.WriteLine($"PDF size in memory: {pdfBytes.Length:N0} bytes");

// Example: return as HTTP response in ASP.NET Core
// return File(pdfBytes, "application/pdf", "form-export.pdf");
Imports IronPdf
Imports System.IO

Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Get raw bytes -- no file required
Dim pdfBytes As Byte() = pdf.BinaryData

' Alternatively, get a MemoryStream for APIs that accept streams
Using stream As MemoryStream = pdf.Stream
    Dim fromStream As Byte() = stream.ToArray()
End Using

Console.WriteLine($"PDF size in memory: {pdfBytes.Length:N0} bytes")

' Example: return as HTTP response in ASP.NET Core
' Return File(pdfBytes, "application/pdf", "form-export.pdf")
$vbLabelText   $csharpLabel

Die BinaryData-Eigenschaft führt eine O(1)-Kopie des vorab berechneten Byte-Arrays durch. Die Eigenschaft Stream gibt ein neues MemoryStream zurück, das den suchbaren Zugriff für Bibliotheken unterstützt, die Stream-Eingaben erwarten - nützlich beim Verketten von Komprimierung oder Verschlüsselung vor der Auslieferung der endgültigen Bytes. Weitere Details zur PDF-Verarbeitung im Arbeitsspeicher finden Sie im Leitfaden zum PDF-Speicherstream .

Wie wendet man Sicherheitseinstellungen vor dem Speichern an?

Formularexporte enthalten oft sensible Daten. Die Sicherheits-API von IronPDF verschlüsselt die PDF-Datei und schränkt ein, was Empfänger damit tun können:

using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Restrict access
pdf.SecuritySettings.OwnerPassword          = "adminSecretKey";
pdf.SecuritySettings.UserPassword           = "viewerPass";
pdf.SecuritySettings.AllowUserPrinting      = true;   // allow printing
pdf.SecuritySettings.AllowUserCopyPasteContent = false; // block copy
pdf.SecuritySettings.AllowUserAnnotations   = false;

pdf.SaveAs("SecureForm.pdf");
Console.WriteLine("Password-protected PDF created.");
using IronPdf;

var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf(formHtml);

// Restrict access
pdf.SecuritySettings.OwnerPassword          = "adminSecretKey";
pdf.SecuritySettings.UserPassword           = "viewerPass";
pdf.SecuritySettings.AllowUserPrinting      = true;   // allow printing
pdf.SecuritySettings.AllowUserCopyPasteContent = false; // block copy
pdf.SecuritySettings.AllowUserAnnotations   = false;

pdf.SaveAs("SecureForm.pdf");
Console.WriteLine("Password-protected PDF created.");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Restrict access
pdf.SecuritySettings.OwnerPassword = "adminSecretKey"
pdf.SecuritySettings.UserPassword = "viewerPass"
pdf.SecuritySettings.AllowUserPrinting = True ' allow printing
pdf.SecuritySettings.AllowUserCopyPasteContent = False ' block copy
pdf.SecuritySettings.AllowUserAnnotations = False

pdf.SaveAs("SecureForm.pdf")
Console.WriteLine("Password-protected PDF created.")
$vbLabelText   $csharpLabel

Durch die Festlegung eines Besitzerpassworts können Administratoren die Berechtigungsflags steuern, während das Benutzerpasswort den Zugriff auf Dokumente vollständig sperrt. Der Parameter AllowUserPrinting ist hier besonders relevant – Sie können dem Empfänger ermöglichen, das exportierte Formular erneut auszudrucken, ohne ihm Bearbeitungsrechte zu geben. Alle Details finden Sie im PDF-Leitfaden zu Berechtigungen und Passwörtern .

Wie vergleicht man Druckansätze für C#-Formulare?

Die Wahl zwischen der nativen Bitmap-Erfassung von WinForms (PrintDocument), GDI+ und dem HTML-Rendering von IronPDF hängt von Kompromissen hinsichtlich Genauigkeit, Komplexität und Portabilität ab:

Vergleich von C#-Formular-zu-PDF-Konvertierungsansätzen
Ansatz Ausgabetreue Codekomplexität Plattformübergreifend CSS-Unterstützung Am besten für
PrintDocument + PDF-Druckertreiber Medium Medium Nur für Windows Keine Legacy WinForms mit vorhandener Drucklogik
GDI+ Bitmap-Erfassung (Control.DrawToBitmap) Hoch (Raster) Niedrig Nur für Windows Keine Schnelle Aufnahmen im Screenshot-Stil
IronPDF HTML-Darstellung Hoch (Vektor) Niedrig Windows, Linux, macOS, Docker Vollständiges CSS3 Professional, portable, datengesteuerte Exporte
ReportViewer (RDLC) Hoch Hoch Nur für Windows Begrenzt Komplexe, paginierte Berichte mit Gruppierung

IronPDFs HTML-basierter Ansatz erzeugt Vektor-PDFs, die sich in jeder Zoom nahtlos skalieren lassen und auf jedem Gerät gestochen scharf gedruckt werden. Da die Rendering-Engine Chromium nutzt, funktionieren CSS Media Queries, Flexbox-Layouts und Google Fonts wie erwartet – etwas, das die GDI+-Bitmap-Erfassung nicht leisten kann. Die Bibliothek läuft auch unter Linux-Umgebungen und innerhalb von Docker-Containern und ist damit die einzige Option in dieser Tabelle, die außerhalb von Windows funktioniert.

Was passiert, wenn das Formular mehrere Registerkarten hat?

WinForms mit mehreren Registerkarten sind in Geschäftsanwendungen weit verbreitet. Da das PDF aus HTML und nicht aus der Live-GDI+-Oberfläche generiert wird, haben Sie die volle Kontrolle darüber, welche Tab-Inhalte angezeigt werden. Erstellen Sie für jeden Tab einen eigenen HTML-Abschnitt und verketten Sie diese vor dem Rendern. Die Pipeline fließt von tab-HTML-Strings über ChromePdfRenderer zu einem einzigen, durchgehenden mehrseitigen PDF - ein logischer Abschnitt pro Tab. Alternativ können Sie jeden Tab unabhängig rendern und die resultierenden PdfDocument Objekte mit der Merge-API von IronPDF zusammenführen.

Wie führen Sie die Formularvalidierung vor dem Export durch?

Es werden nur gültige Formulardaten exportiert. Ein einfaches Schutzmuster verhindert die Generierung von PDFs aus unvollständigen Eingaben: Zuerst werden die Felder validiert, und erst wenn alle erforderlichen Felder bestanden sind, wird mit der HTML-Generierung und -Darstellung fortgefahren. Falls ein Feld einen Fehler aufweist, markieren Sie den Fehler in der Benutzeroberfläche und brechen Sie den Export ab. Dadurch wird die Konsistenz der exportierten PDFs gewährleistet und nachfolgende Verwirrung durch unvollständige Daten vermieden. Laut Microsofts Dokumentation zur Windows Forms-Validierung ist ErrorProvider der Standardmechanismus für eine Rückmeldung zur Feldvalidierung vor jeder Aktion.

Wie stellt man den PDF-Export aus ASP.NET Core bereit?

Mit ASP.NET Core erstellte Webformulare können mithilfe derselben ChromePdfRenderer API in PDF exportiert werden. Die gerenderten Bytes werden direkt als Datei zurückgegeben:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/forms")]
public class FormExportController : ControllerBase
{
    [HttpPost("export")]
    public IActionResult ExportFormAsPdf([FromBody] FormDataModel formData)
    {
        // Build HTML from submitted form data
        string html = $"""
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; padding: 30px; }}
                    h1   {{ color: #1a4a8a; }}
                    dl   {{ display: grid; grid-template-columns: 200px 1fr; gap: 8px 16px; }}
                    dt   {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>{formData.FormTitle}</h1>
                <dl>
                    <dt>Applicant Name</dt><dd>{formData.ApplicantName}</dd>
                    <dt>Submission Date</dt><dd>{DateTime.UtcNow:dd MMM yyyy}</dd>
                    <dt>Reference ID</dt><dd>{formData.ReferenceId}</dd>
                </dl>
            </body>
            </html>
            """;

        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

        PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
        byte[] pdfBytes = pdf.BinaryData;

        string fileName = $"form-{formData.ReferenceId}-{DateTime.UtcNow:yyyyMMdd}.pdf";
        return File(pdfBytes, "application/pdf", fileName);
    }
}

public record FormDataModel(string FormTitle, string ApplicantName, string ReferenceId);
using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/forms")]
public class FormExportController : ControllerBase
{
    [HttpPost("export")]
    public IActionResult ExportFormAsPdf([FromBody] FormDataModel formData)
    {
        // Build HTML from submitted form data
        string html = $"""
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; padding: 30px; }}
                    h1   {{ color: #1a4a8a; }}
                    dl   {{ display: grid; grid-template-columns: 200px 1fr; gap: 8px 16px; }}
                    dt   {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>{formData.FormTitle}</h1>
                <dl>
                    <dt>Applicant Name</dt><dd>{formData.ApplicantName}</dd>
                    <dt>Submission Date</dt><dd>{DateTime.UtcNow:dd MMM yyyy}</dd>
                    <dt>Reference ID</dt><dd>{formData.ReferenceId}</dd>
                </dl>
            </body>
            </html>
            """;

        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

        PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
        byte[] pdfBytes = pdf.BinaryData;

        string fileName = $"form-{formData.ReferenceId}-{DateTime.UtcNow:yyyyMMdd}.pdf";
        return File(pdfBytes, "application/pdf", fileName);
    }
}

public record FormDataModel(string FormTitle, string ApplicantName, string ReferenceId);
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("api/forms")>
Public Class FormExportController
    Inherits ControllerBase

    <HttpPost("export")>
    Public Function ExportFormAsPdf(<FromBody> formData As FormDataModel) As IActionResult
        ' Build HTML from submitted form data
        Dim html As String = $"
            <!DOCTYPE html>
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; padding: 30px; }}
                    h1   {{ color: #1a4a8a; }}
                    dl   {{ display: grid; grid-template-columns: 200px 1fr; gap: 8px 16px; }}
                    dt   {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>{formData.FormTitle}</h1>
                <dl>
                    <dt>Applicant Name</dt><dd>{formData.ApplicantName}</dd>
                    <dt>Submission Date</dt><dd>{DateTime.UtcNow:dd MMM yyyy}</dd>
                    <dt>Reference ID</dt><dd>{formData.ReferenceId}</dd>
                </dl>
            </body>
            </html>
            "

        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

        Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
        Dim pdfBytes As Byte() = pdf.BinaryData

        Dim fileName As String = $"form-{formData.ReferenceId}-{DateTime.UtcNow:yyyyMMdd}.pdf"
        Return File(pdfBytes, "application/pdf", fileName)
    End Function
End Class

Public Class FormDataModel
    Public Property FormTitle As String
    Public Property ApplicantName As String
    Public Property ReferenceId As String

    Public Sub New(formTitle As String, applicantName As String, referenceId As String)
        Me.FormTitle = formTitle
        Me.ApplicantName = applicantName
        Me.ReferenceId = referenceId
    End Sub
End Class
$vbLabelText   $csharpLabel

Dieser Controller empfängt Formulardaten als JSON, generiert das PDF im Speicher und streamt es als Dateidownload zurück. Es werden keine temporären Dateien auf dem Server erstellt. Bei Blazor Anwendungen ist der Ansatz ähnlich – man ruft denselben Rendering-Code von einem Dienst aus auf und sendet die Bytes über IJSRuntime an den Browser. Die vollständigen ASP.NET Integrationsmuster sind im ASP.NET -zu-PDF-Leitfaden dokumentiert.

Welchen MIME-Typ und welche Content-Disposition sollten Sie verwenden?

Als Inhaltstyp wird immer application/pdf zurückgegeben. Verwenden Sie Content-Disposition: inline, um die PDF-Datei im Browser anzuzeigen, oder Content-Disposition: attachment, um einen Download zu erzwingen. Der Dateiname wird im Speicherdialog des Browsers angezeigt, wenn attachment verwendet wird. Wählen Sie daher einen aussagekräftigen Namen, der eine Referenz-ID oder ein Datum enthält.

Wie speichert man generierte PDFs im Cache?

Wenn der gleiche Formularexport wiederholt angefordert wird, wird das Byte-Array zwischengespeichert, um ein erneutes Rendern zu vermeiden. IMemoryCache funktioniert für Einzelserver-Bereitstellungen; Für Multi-Instanz-Setups sollte ein verteilter Cache wie Redis verwendet werden. Legen Sie ein Ablaufdatum fest, das der Häufigkeit der Änderungen der zugrunde liegenden Formulardaten entspricht.

Was sind die besten Vorgehensweisen für den Export von Formularen in PDF-Dateien?

Konsistente, qualitativ hochwertige Formularexporte ergeben sich aus wenigen wiederholbaren Mustern:

  • Halten Sie HTML einfach. Vermeiden Sie JavaScript-lastige Templates – reines HTML und CSS werden schneller gerendert und erzeugen kleinere PDFs. Aktivieren Sie RenderingOptions.EnableJavaScript nur dann, wenn Formularberechnungen davon abhängen.
  • Verwenden Sie print-CSS. Setzen Sie CssMediaType = PdfCssMediaType.Print und definieren Sie @media print Regeln in Ihrem Stylesheet. Dadurch werden nur bildschirmbasierte Elemente wie Navigationsleisten und Seitenleisten aus der exportierten PDF-Datei entfernt.
  • Benutzereingaben bereinigen. HTML-Entitäten in allen Feldwerten, die Sie in die Vorlage einfügen, maskieren, um fehlerhaftes Markup oder, in Ausnahmefällen, das Einschleusen von Skripten in das PDF zu verhindern.
  • PdfDocument-Objekte freigeben. Nicht verwaltete Ressourcen werden bis zur Freigabe reserviert. Verwenden Sie using Deklarationen oder rufen Sie Dispose() nach dem Speichern explizit auf.
  • Testen Sie mit Produktionsdaten. Formulare mit langem Text, Sonderzeichen oder eingebetteten Bildern können zu unerwarteten Layouts führen. Führen Sie während der Entwicklung Exporte anhand realer Datenbeispiele durch.

Die Referenzdokumente der Rendering-Optionen enthalten alle verfügbaren Einstellungen, von benutzerdefinierten Papierformaten über benutzerdefinierte Ränder bis hin zur Seitenausrichtung .

Wie gehen Sie mit großen oder mehrseitigen Formularen um?

IronPDF erstellt die Seiten automatisch anhand der Inhaltshöhe und des gewählten Papierformats. Fügen Sie page-break-before: always in den Abschnittscontainern im CSS ein, wenn ein neuer Formularabschnitt immer auf einer neuen Seite beginnen soll. Bei Formularen mit Hunderten von Feldern reduziert die Vorabzuweisung eines MemoryStream mit einer geschätzten Kapazität den GC-Druck während des Byte-Array-Kopierens.

Wie fügt man eine digitale Signatur hinzu?

Unterzeichnete Exportformulare haben in vielen Rechtsordnungen rechtliche Bedeutung. IronPDF unterstützt digitale Zertifikate, die in PFX-Dateien oder Windows-Zertifikatspeichern gespeichert sind:

// Load the certificate and sign in one step
var signature = new IronPdf.Signing.PdfSignature("certificate.pfx", "certPassword");
pdf.Sign(signature);
pdf.SaveAs("SignedForm.pdf");
// Load the certificate and sign in one step
var signature = new IronPdf.Signing.PdfSignature("certificate.pfx", "certPassword");
pdf.Sign(signature);
pdf.SaveAs("SignedForm.pdf");
Imports IronPdf.Signing

' Load the certificate and sign in one step
Dim signature As New PdfSignature("certificate.pfx", "certPassword")
pdf.Sign(signature)
pdf.SaveAs("SignedForm.pdf")
$vbLabelText   $csharpLabel

Laut der Übersicht zu digitalen PDF-Signaturen bestätigt eine digitale Signatur die Herkunft des Dokuments und erkennt nachträgliche Änderungen. Der PDF-Leitfaden zur digitalen Signatur behandelt die Zertifikatskonfiguration und die sichtbaren Signaturfelder im Detail.

Welche Kernpunkte sollten Sie mitnehmen?

Die Konvertierung eines C# Windows Forms in PDF mit IronPDF reduziert sich auf drei Schritte: Erstellen einer HTML-Darstellung der Formulardaten, Übergeben dieser an ChromePdfRenderer und Speichern oder Übertragen des Ergebnisses. Der Ansatz erzeugt Vektor-PDFs, die scharf gedruckt werden, plattformübergreifend funktionieren und das vollständige CSS3-Layoutmodell unterstützen – Vorteile, die GDI+ Bitmap-Erfassung und ältere Druckertreibermethoden nicht bieten können.

Die wichtigsten in diesem Leitfaden behandelten Funktionen:

  • HTML-zu-PDF-Rendering mit ChromePdfRenderer für WinForms und ASP.NET Core
  • Live-Datenbindung von WinForms-Steuerelementen in HTML-Vorlagen
  • Kopf- und Fußzeilen sowie Seitennummerierung mit TextHeaderFooter
  • Ausgabe eines Byte-Arrays im Arbeitsspeicher über BinaryData für HTTP-Antworten und Datenbankspeicherung
  • PDF-Sicherheitseinstellungen: Besitzer-/Benutzerpasswörter und Berechtigungsflags
  • Beifügung einer digitalen Signatur für rechtsverbindliche Exporte

Entdecken Sie die Funktionen von IronPDF , darunter Anmerkungswerkzeuge, Formularfeldbearbeitung, PDF/A-Konformität und vieles mehr. Testen Sie IronPDF kostenlos mit einer 30-tägigen Testlizenz und integrieren Sie es noch heute in Ihren eigenen Formular-Export-Workflow.

Häufig gestellte Fragen

Wie kann ich ein C#-Formular mit IronPDF in PDF konvertieren?

Sie können ein C#-Formular mit IronPDF in PDF konvertieren, indem Sie seine intuitive API nutzen, die es Ihnen ermöglicht, PDF-Konvertierungen effizient ohne komplexen Code durchzuführen.

Warum ist die Konvertierung von PDF-Dokumenten in Byte-Arrays wichtig in .NET-Anwendungen?

Die Konvertierung von PDF-Dokumenten in Byte-Arrays ist wichtig, weil sie die Speicherung von PDFs in Datenbanken, die Übertragung über APIs und die Handhabung von Dokumenteninhalten im Speicher ermöglicht, was alles entscheidende Operationen in modernen .NET-Anwendungen sind.

Welche Vorteile bietet IronPDF bei der Byte-Array-Konvertierung?

IronPDF vereinfacht die Byte-Array-Konvertierung, indem es eine benutzerfreundliche API bietet, die den Prozess optimiert, den Bedarf an komplexem Code reduziert und die Entwicklungseffizienz verbessert.

Kann IronPDF die PDF-Konvertierung im Speicher handhaben?

Ja, IronPDF kann die PDF-Konvertierung im Speicher handhaben, wodurch Entwickler Dokumenteninhalte verwalten können, ohne Dateien auf der Festplatte speichern zu müssen.

Ist es möglich, PDFs mit IronPDF in einer Datenbank zu speichern?

Ja, Sie können PDFs in einer Datenbank speichern, indem Sie sie mit IronPDF in Byte-Arrays konvertieren, was eine nahtlose Integration mit Datenbanksystemen erleichtert.

Wie unterstützt IronPDF die Übertragung von PDF-Dateien über APIs?

IronPDF unterstützt die Übertragung von PDF-Dateien über APIs, indem es die Konvertierung von PDFs in Byte-Arrays ermöglicht, was das Senden und Empfangen von Dokumentendaten über Netzwerkprotokolle erleichtert.

Was macht die API von IronPDF für Entwickler intuitiv?

Die API von IronPDF ist für Entwickler intuitiv gestaltet, indem sie klare und einfache Methoden bereitstellt, die komplexe PDF-Operationen vereinfachen, die Produktivität steigern und die Lernkurve senken.

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