Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Korzystanie z IronPDF
  4. C# Drukowanie formularza do pliku PDF
KORZYSTANIE Z IRONPDF

Drukowanie formularza C# do pliku PDF przy użyciu IronPDF

Curtis Chau
Curtis Chau
Zaktualizowano:

Drukowanie formularza Windows Form do pliku PDF w języku C# jest proste dzięki IronPDF: renderuj reprezentację HTML formularza za pomocą ChromePdfRenderer, zapisz na dysku lub w pamięci i uzyskaj plik PDF o idealnej rozdzielczości za pomocą zaledwie kilku linii kodu.

Eksportowanie aplikacji Windows Forms do formatu PDF jest częstym wymaganiem w oprogramowaniu biznesowym. Niezależnie od tego, czy chcesz archiwizować ekrany wprowadzania danych, generować raporty dla klientów na podstawie stanu formularza, czy też przechwytywać podglądy wydruku bez konieczności korzystania z drukarki, konwersja formularza C# do formatu PDF usprawnia codzienne procesy pracy. IronPDF udostępnia natywny interfejs API .NET, który obsługuje proces konwersji od renderowania HTML do końcowego pliku PDF, pozwalając pominąć zawodne triki drukowania GDI+.

Jak zainstalować IronPDF?

Dodaj IronPDF do swojego projektu za pośrednictwem NuGet. Otwórz konsolę menedżera pakietów i uruchom:

Install-Package IronPdf
Install-Package IronPdf
SHELL

Lub użyj interfejsu CLI platformy .NET:

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Po instalacji dodaj using IronPdf; na początku każdego pliku, który wywołuje API. Pakiet jest również dostępny bezpośrednio na stronie NuGet.org/packages/IronPDF. Klucz licencyjny dla bezpłatnej licencji próbnej jest dostępny na stronie IronPDF.com/licensing/, co pozwala na odblokowanie wydruków bez znaku wodnego podczas oceny.

Jak przekonwertować formularz Windows Form na plik PDF przy użyciu HTML?

Najbardziej niezawodną metodą konwersji formularza C# do formatu PDF jest utworzenie migawki HTML danych formularza i wyrenderowanie tej migawki za pomocą ChromePdfRenderer. Takie podejście oddziela renderowanie wizualne od powierzchni GDI+ WinForms, zapewniając ostry, przenośny wynik, który wygląda identycznie w każdej przeglądarce PDF.

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

ChromePdfRenderer wykorzystuje silnik Chromium typu headless, dzięki czemu układy CSS, osadzone czcionki, a nawet zapytania dotyczące mediów PRINT są renderowane wiernie. Zamień wartości pól zakodowane na stałe na dane powiązane z kontrolkami formularza w czasie wykonywania, aby uzyskać w pełni dynamiczne podejście. Poradnik dotyczący konwersji HTML do PDF szczegółowo omawia wszystkie dostępne opcje renderowania.

Jak pobierać dane na żywo z elementów formularza?

Zamiast ręcznie kodować HTML, odczytaj wartości bezpośrednio z kontrolek WinForms i wstaw je do szablonu:

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

Ten fragment traktuje eksport formularza jak mini zadanie raportowania: zbiera wartości pól, osadza je w szablonie HTML, renderuje, a następnie zapisuje w miejscu wybranym przez użytkownika. Możesz rozszerzyć tabelę HTML o tyle pól, ile zawiera formularz. W przypadku formularzy z wieloma zakładkami należy utworzyć oddzielne bloki <section> dla każdej zakładki i pozwolić IronPDF na naturalną paginację.

Jak dodać nagłówki i stopki?

Nagłówki i stopki nadają eksportowanemu formularzowi profesjonalny wygląd. Klasa TextHeaderFooter w IronPDF umieszcza tekst na górze i na dole każdej strony bez zmiany kodu HTML treści:

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

Tokeny dynamiczne, takie jak {page}, {total-pages} i {date}, są automatycznie rozpoznawane w momencie renderowania. W przypadku wyników z brandingiem należy zamienić TextHeaderFooter na HtmlHeaderFooter i dostarczyć pełny kod HTML, w tym logo firmy. Przewodnik z nagłówkami i stopkami pokazuje wszystkie dostępne tokeny i opcje układu.

Jak przekonwertować formularz na tablicę bajtów zamiast na plik?

Zapisywanie bezpośrednio na dysku jest wygodne, ale wiele aplikacji musi przesyłać plik PDF przez HTTP, przechowywać go w bazie danych lub przekazywać do kolejnej usługi. W takich przypadkach należy pominąć plik i pracować z surowymi bajtami:

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

Właściwość BinaryData wykonuje kopię wstępnie obliczonej tablicy bajtów o złożoności O(1). Właściwość Stream zwraca nowy obiekt MemoryStream, który obsługuje dostęp z możliwością wyszukiwania dla bibliotek oczekujących danych wejściowych w postaci strumienia — przydatne podczas łączenia kompresji lub szyfrowania przed dostarczeniem ostatecznych bajtów. Więcej szczegółów na temat obsługi plików PDF w pamięci można znaleźć w przewodniku dotyczącym strumienia pamięci PDF.

Jak zastosować ustawienia zabezpieczeń przed zapisaniem?

Eksporty formularzy często zawierają dane wrażliwe. API bezpieczeństwa IronPDF szyfruje plik PDF i ogranicza możliwości odbiorców w zakresie jego wykorzystania:

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

Ustawienie hasła właściciela pozwala administratorom kontrolować uprawnienia, podczas gdy hasło użytkownika całkowicie ogranicza dostęp do dokumentów. Szczególnie istotna jest tutaj flaga AllowUserPrinting — pozwala ona odbiorcy na ponowne wydrukowanie wyeksportowanego formularza bez przyznawania mu uprawnień do edycji. Pełne szczegóły znajdują się w przewodniku dotyczącym uprawnień i haseł w formacie PDF.

Jak porównać metody drukowania w formularzach C#?

Wybór między natywnym PrintDocument WinForms, przechwytywaniem bitmap GDI+ a renderowaniem HTML IronPDF zależy od kompromisów w zakresie wierności, złożoności i przenośności:

Porównanie metod konwersji formularzy C# do formatu PDF
Podejście Wierność tłumaczenia Złożoność kodu Wieloplatformowe Obsługa CSS Najlepsze dla
PrintDocument + sterownik drukarki PDF Medium Medium Tylko dla systemu Windows None Starsze wersje WinForms z istniejącą logiką drukowania
Przechwytywanie bitmap GDI+ (Control.DrawToBitmap) Wysoka (raster) Low Tylko dla systemu Windows None Szybkie zrzuty ekranu
Renderowanie HTML w IronPDF Wysoka (wektorowa) Low Windows, Linux, macOS, Docker Pełny CSS3 Profesjonalny, przenośny eksport oparty na danych
ReportViewer (RDLC) High High Tylko dla systemu Windows Ograniczone Złożone raporty paginowane z grupowaniem

Podejście oparte na HTML stosowane przez IronPDF pozwala uzyskać wektorowy plik PDF, który skaluje się płynnie przy każdym poziomie powiększenia i drukuje się ostro na każdym urządzeniu. Ponieważ silnikiem renderującym jest Chromium, zapytania o media CSS, układy flexbox oraz czcionki Google działają zgodnie z oczekiwaniami — czego nie jest w stanie odtworzyć przechwytywanie bitmap GDI+. Biblioteka działa również w środowiskach Linux oraz w kontenerach Docker, co czyni ją jedyną opcją w tej tabeli, która działa poza systemem Windows.

Co się dzieje, gdy formularz ma wiele zakładek?

Formularze WinForms z wieloma kartami są powszechnie stosowane w aplikacjach biznesowych. Ponieważ plik PDF jest generowany z kodu HTML, a nie z aktywnej powierzchni GDI+, masz pełną kontrolę nad tym, która zawartość zakładki zostanie wyświetlona. Utwórz jedną sekcję HTML na każdą kartę i połącz je przed renderowaniem. Proces przebiega od ciągów znaków HTML z zakładek poprzez ChromePdfRenderer do pojedynczego, ciągłego, wielostronicowego pliku PDF — jedna sekcja logiczna na zakładkę. Alternatywnie można renderować każdą kartę niezależnie, a następnie połączyć powstałe obiekty PdfDocument za pomocą interfejsu API scalania IronPDF.

Jak radzisz sobie z walidacją formularzy przed eksportem?

Eksportuj tylko prawidłowe dane formularza. Prosty wzorzec zabezpieczający zapobiega generowaniu plików PDF na podstawie niekompletnych zgłoszeń: najpierw należy zweryfikować pola, a dopiero po sprawdzeniu wszystkich wymaganych pól przejść do generowania i renderowania kodu HTML. Jeśli którekolwiek pole nie zostanie wypełnione, należy zaznaczyć błąd w interfejsie użytkownika i przerwać eksport. Dzięki temu eksportowane pliki PDF są spójne i nie ma zamieszania wynikającego z niekompletnych danych. Zgodnie z dokumentacją Microsoftu dotyczącą walidacji w Windows Forms, ErrorProvider jest standardowym mechanizmem informacji zwrotnej dotyczącej walidacji na poziomie pól przed wykonaniem jakiejkolwiek akcji.

Jak obsłużyć eksport do formatu PDF z ASP.NET Core?

Formularze internetowe utworzone przy użyciu .NET Core mogą być eksportowane do formatu PDF przy użyciu tego samego interfejsu API ChromePdfRenderer. Wygenerowane bajty są zwracane bezpośrednio jako wynik w postaci pliku:

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

Ten kontroler odbiera dane z formularza w formacie JSON, generuje plik PDF w pamięci i przesyła go z powrotem jako plik do pobrania. Na serwerze nie są tworzone żadne pliki tymczasowe. W przypadku aplikacji Blazor podejście jest podobne — wywołaj ten sam kod renderowania z usługi i prześlij bajty do przeglądarki za pomocą IJSRuntime. Pełne wzorce integracji ASP.NET są udokumentówane w przewodniku ASP.NET to PDF.

Jakiego typu MIME i Content-Disposition należy używać?

Zawsze należy podawać application/pdf jako typ zawartości. Użyj Content-Disposition: inline, aby wyświetlić plik PDF w przeglądarce, lub Content-Disposition: attachment, aby wymusić pobranie. Nazwa pliku pojawia się w oknie dialogowym zapisu przeglądarki, gdy używane jest attachment, więc wybierz sensowną nazwę, która zawiera identyfikator odniesienia lub datę.

Jak buforować wygenerowane pliki PDF?

Jeśli ten sam eksport formularza jest żądany wielokrotnie, należy zapisać tablicę bajtów w pamięci podręcznej, aby uniknąć ponownego renderowania. IMemoryCache działa w przypadku wdrożeń na jednym serwerze; użyj pamięci podręcznej rozproszonej, takiej jak Redis, w konfiguracjach wieloinstancyjnych. Ustaw datę wygaśnięcia, która odpowiada częstotliwości zmian danych w formularzu.

Jakie są najlepsze praktyki dotyczące eksportu formularzy do formatu PDF?

Spójne, wysokiej jakości eksporty formularzy wynikają z kilku powtarzalnych wzorców:

  • Używaj prostego kodu HTML. Unikaj szablonów z dużą ilością kodu JavaScript — czysty HTML i CSS renderują się szybciej i tworzą mniejsze pliki PDF. Włącz RenderingOptions.EnableJavaScript tylko wtedy, gdy obliczenia w formularzu są od tego zależne.
  • Użyj CSS do PRINT. Ustaw CssMediaType = PdfCssMediaType.Print i zdefiniuj reguły @media print w swoim arkuszu stylów. Dzięki temu z eksportowanego pliku PDF usuwane są elementy wyświetlane wyłącznie na ekranie, takie jak paski nawigacyjne i paski boczne.
  • Oczyść dane wprowadzane przez użytkownika. Zastosuj escape'owanie encji HTML w każdej wartości pola, którą wstawiasz do szablonu, aby zapobiec uszkodzeniu znaczników lub, w skrajnych przypadkach, wstrzyknięciu skryptu do pliku PDF.
  • Usuń obiekty PdfDocument. Zasoby niezarządzane są przechowywane do momentu ich usunięcia. Użyj deklaracji using lub wywołaj Dispose() jawnie po zapisaniu.
  • Przetestuj na danych produkcyjnych. Formularze z długim tekstem, znakami specjalnymi lub osadzonymi obrazami mogą generować nieoczekiwane układy. Podczas tworzenia oprogramowania należy przeprowadzać eksporty na prawdziwych próbkach danych.

Opcje renderowania odnoszą się do wszystkich dostępnych ustawień, od niestandardowych rozmiarów papieru po niestandardowe marginesy i orientację strony.

Jak radzisz sobie z dużymi lub wielostronicowymi formularzami?

IronPDF automatycznie dzieli dokument na strony na podstawie wysokości treści i wybranego rozmiaru papieru. Wstaw page-break-before: always w kontenerach sekcji w CSS, jeśli nowa sekcja formularza ma zawsze zaczynać się na nowej stronie. W przypadku formularzy zawierających setki pól wstępne przydzielenie MemoryStream o szacowanej pojemności zmniejsza obciążenie GC podczas kopiowania tablicy bajtów.

Jak dodać podpis cyfrowy?

Eksporty podpisanych formularzy mają moc prawną w wielu jurysdykcjach. IronPDF obsługuje certyfikaty cyfrowe przechowywane w plikach PFX lub magazynach certyfikatów systemu Windows:

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

Zgodnie z opisem podpisów cyfrowych w formacie PDF, podpis cyfrowy poświadcza pochodzenie dokumentu i wykrywa wszelkie modyfikacje dokonane po podpisaniu. Przewodnik po podpisywaniu cyfrowym plików PDF szczegółowo omawia konfigurację certyfikatów i widoczne pola podpisu.

Jakie kluczowe punkty należy zapamiętać?

Konwersja formularza C# Windows Form do formatu PDF za pomocą IronPDF sprowadza się do trzech kroków: utworzenia reprezentacji HTML danych formularza, przekazania jej do ChromePdfRenderer oraz zapisania lub przesłania wyniku. Takie podejście pozwala uzyskać wektorowe pliki PDF, które drukują się ostro, działają na różnych platformach i obsługują pełny model układu CSS3 — to zalety, których nie mogą dorównać metody przechwytywania bitmap GDI+ ani starsze sterowniki drukarek.

Kluczowe funkcje omówione w tym przewodniku:

  • Renderowanie HTML do PDF za pomocą ChromePdfRenderer dla WinForms i ASP.NET Core
  • Powiązanie danych na żywo z kontrolkami WinForms do szablonów HTML
  • Nagłówki, stopki i numeracja stron z TextHeaderFooter
  • Wyprowadzanie tablicy bajtów w pamięci za pomocą BinaryData dla odpowiedzi HTTP i przechowywania w bazie danych
  • Ustawienia zabezpieczeń plików PDF: hasła właściciela/użytkownika oraz flagi uprawnień
  • Załącznik z podpisem cyfrowym dla eksportów o mocy prawnej

Zapoznaj się z zestawem funkcji IronPDF, aby zobaczyć narzędzia do adnotacji, edycję pól formularzy, zgodność z PDF/A i wiele więcej. Wypróbuj IronPDF za darmo dzięki 30-dniowemu okresowi próbnemu i zastosuj go już dziś w swoim procesie eksportu formularzy.

Często Zadawane Pytania

Jak przekonwertować formularz C# do formatu PDF za pomocą IronPDF?

Formularz C# można przekonwertować do formatu PDF za pomocą IronPDF, korzystając z jego intuicyjnego interfejsu API, który pozwala na wydajną obsługę konwersji plików PDF bez skomplikowanego kodu.

Dlaczego konwersja dokumentów PDF na tablice bajtów jest ważna w aplikacjach .NET?

Konwersja dokumentów PDF na tablice bajtów jest ważna, ponieważ umożliwia przechowywanie plików PDF w bazach danych, przesyłanie ich za pośrednictwem interfejsów API oraz obsługę zawartości dokumentów w pamięci, co stanowi kluczowe operacje w nowoczesnych aplikacjach .NET.

Jakie są zalety korzystania z IronPDF do konwersji tablic bajtów?

IronPDF upraszcza konwersję tablic bajtów, udostępniając łatwy w użyciu interfejs API, który usprawnia ten proces, zmniejszając potrzebę stosowania skomplikowanego kodu i zwiększając wydajność programowania.

Czy IronPDF obsługuje konwersję plików PDF w pamięci?

Tak, IronPDF może obsługiwać konwersję plików PDF w pamięci, co pozwala programistom zarządzać treścią dokumentów bez konieczności zapisywania plików na dysku.

Czy za pomocą IronPDF można przechowywać pliki PDF w bazie danych?

Tak, można przechowywać pliki PDF w bazie danych, konwertując je na tablice bajtów za pomocą IronPDF, co ułatwia płynną integrację z systemami baz danych.

W jaki sposób IronPDF pomaga w przesyłaniu plików PDF za pośrednictwem interfejsów API?

IronPDF ułatwia przesyłanie plików PDF za pośrednictwem interfejsów API, umożliwiając konwersję plików PDF na tablice bajtów, co ułatwia wysyłanie i odbieranie danych dokumentów za pośrednictwem protokołów sieciowych.

Co sprawia, że API IronPDF jest intuicyjne dla programistów?

API IronPDF zostało zaprojektowane tak, aby było intuicyjne dla programistów, zapewniając jasne i proste metody, które upraszczają złożone operacje na plikach PDF, zwiększając produktywność i skracając czas potrzebny na opanowanie obsługi.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie