Nie znalazłeś tego, czego szukałeś?
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

Jak zbudować edytor PDF w aplikacjach UWP z C#

Curtis Chau
Curtis Chau
Zaktualizowano:

Drukowanie formularza Windows w PDF w C# jest proste z IronPDF: renderuj HTML formy za pomocą ChromePdfRenderer, zapisz na dysku lub w pamięci, i dostarcz doskonale odwzorowany PDF w zaledwie kilku liniach 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

Lub użyj interfejsu CLI platformy .NET:

dotnet add package IronPdf

Po instalacji, dodaj using IronPdf; na początku dowolnego 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 wiarygodną metodą konwersji formularza C# do PDF jest zbudowanie migawki HTML danych formularza i renderowanie 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 napędza silnik Chromium w trybie bezgłowym, więc układy CSS, osadzone czcionki, a nawet zapytania dotyczące mediów drukarskich są wiernie renderowane. 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. Dla formularzy z wieloma kartami, zbuduj osobne bloki

dla każdej karty i pozwól IronPDF na naturalne paginowanie.

Jak dodać nagłówki i stopki?

Nagłówki i stopki nadają eksportowanemu formularzowi profesjonalny wygląd. Klasa TextHeaderFooter IronPDF stempluje tekst na górze i na dole każdej strony, nie zmieniając HTML-a 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

Dynamiczne tokeny takie jak {page}, {total-pages} i {date} rozwiązują się automatycznie w czasie renderowania. Dla oznakowanego wyjścia, zamień TextHeaderFooter na HtmlHeaderFooter i dostarcz pełny HTML zawierający loga 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łasność BinaryData wykonuje kopiowanie O(1) pre-skomputowanej tablicy bajtów. Własność Stream zwraca nowy MemoryStream, który obsługuje dostęp sekwencyjny dla bibliotek oczekujących strumieniowego wejścia -- przydatne przy łańcuchowaniu kompresji lub szyfrowania przed dostarczeniem końcowych 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. Flaga AllowUserPrinting jest tutaj szczególnie istotna -- możesz pozwolić odbiorcy ponownie wydrukować wyeksportowany formularz bez nadawania mu praw do edycji. Pełne szczegóły znajdują się w przewodniku dotyczącym uprawnień i haseł w formacie PDF.

Jak porównać podejścia do druku formularzy w C#?

Wybór pomiędzy natywnym PrintDocument WinForms, przechwytywaniem bitmap GDI+ oraz renderowaniem HTML IronPDF zależy od kompromisów w zakresie dokładnoś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 Wielopłatformowe Obsługa CSS Najlepsze dla
PrintDocument + sterownik drukarki PDF Srednie Srednie Tylko dla systemu Windows None Starsze wersje WinForms z istniejącą logiką drukowania
Przechwytywanie bitmap GDI+ (Control.DrawToBitmap) Wysoka (raster) Niski Tylko dla systemu Windows None Szybkie zrzuty ekranu
Renderowanie HTML w IronPDF Wysoka (wektorowa) Niski Windows, Linux, macOS, Docker Pełny CSS3 Profesjonalny, przenośny eksport oparty na danych
ReportViewer (RDLC) Duze Duze 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. Pipeline przebiega od ciągów HTML karty przez ChromePdfRenderer do pojedynczego, ciągłego dokumentu PDF na wielu stronach -- jedna logiczna sekcja na kartę. Alternatywnie, renderuj każdą kartę indywidualnie i scal powstałe obiekty PdfDocument z 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 formularzy Windows, ErrorProvider jest standardowym mechanizmem dla weryfikacji na poziomie pola przed każdą akcją.

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

Formularze internetowe zbudowane za pomocą ASP.NET Core mogą eksportować do PDF używając tego samego 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. Dla aplikacji Blazor, podejście jest podobne -- wywołaj ten sam kod renderowania z usługi i przesyłaj bajty do przeglądarki za pomocą IJSRuntime. Pełne wzorce integracji ASP.NET są udokumentowane w przewodniku ASP.NET to PDF.

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

Zawsze zwracaj application/pdf jako typ zawartości. Użyj Content-Disposition: inline, aby wyświetlić PDF w przeglądarce, lub Content-Disposition: attachment, aby wymusić pobranie. Nazwa pliku pojawia się w oknie dialogowym zapisu przeglądarki po użyciu attachment, więc wybierz znaczącą nazwę zawierającą identyfikator referencyjny 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 dla 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 gdy obliczenia formularza są od tego zależne.
  • Używaj CSS dla druku. 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() explicite 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 paginuje na podstawie wysokości zawartości i wybranego rozmiaru papieru. Wstaw page-break-before: always do kontenerów sekcji w CSS, gdy nowa sekcja formularza powinna zawsze zaczynać się na nowej stronie. Dla formularzy z setkami pól, prealokowanie MemoryStream z szacowaną 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 Windows w C# do PDF za pomocą IronPDF sprowadza się do trzech kroków: zbuduj HTML-ową reprezentację danych formularza, przekaż ją do ChromePdfRenderer i zapisz lub przekaż wynik. 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 na 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 za pomocą TextHeaderFooter
  • Wyjście tablicy bajtów w pamięci za pomocą BinaryData dla odpowiedzi HTTP i przechowywania w bazach 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 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

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie