Jak dynamicznie generować PDF-y w .NET z użyciem IronPDF

Czym jest dynamiczne generowanie plików PDF w .NET?

Dynamiczne generowanie plików PDF oznacza tworzenie dokumentów PDF w czasie wykonywania, gdzie każda część treści — nazwy, liczby, daty, tabele, wykresy — pochodzi z danych na żywo, a nie ze stałego układu. Struktura dokumentu może pozostać taka sama, ale jego zawartość zmienia się przy każdym żądaniu.

Oto scenariusze, w których takie podejście zapewnia największą wartość:

• Generowanie faktur — pozycje, sumy, stawki podatkowe i warunki płatności różnią się w zależności od transakcji
• Raporty finansowe — wykresy i tabele podsumowujące pobierane są z bazy danych aktualizowanej w ciągu dnia
• Certyfikaty i dyplomy — nazwiska odbiorców, daty ukończenia i szczegóły kursów różnią się w zależności od dokumentu
• Dokumenty prawne — umowy zawierają klauzule specyficzne dla klienta oraz zasady jurysdykcji
• Dokumentacja medyczna — dane demograficzne pacjentów, wyniki badań i plany opieki wymagają indywidualnego formatowania

Tradycyjną alternatywą jest utrzymywanie biblioteki statycznych szablonów i ręczna edycja każdego z nich dla poszczególnych wariantów. Takie podejście szybko się załamuje wraz ze wzrostem objętości dokumentów i mnożeniem się reguł biznesowych. Dzięki silnikowi konwersji HTML na PDF firmy IronPDF wystarczy raz napisać logikę generowania, aby tworzyć tysiące poprawnie sformatowanych plików PDF z dokładnymi danymi bez żadnej ręcznej interwencji.

IronPDF działa na systemach Windows, Linux, macOS, Docker i Azure — ten sam interfejs API działa identycznie na wszystkich platformach. Ta spójność między platformami oznacza, że możesz tworzyć oprogramowanie lokalnie i wdrażać je w kontenerze w chmurze bez żadnych dostosowań specyficznych dla danej platformy. Biblioteka jest przeznaczona dla platformy .NET 6 i nowszych, obsługując zarówno najnowsze wersje .NET, jak i wersje z długoterminowym wsparciem.

Jak zainstalować i skonfigurować bibliotekę?

IronPDF jest dystrybuowany jako pakiet NuGet i integruje się z każdym projektem opartym na platformie .NET 6 lub nowszej, w tym z aplikacjami ASP.NET Core, Blazor i konsolowymi. Zainstaluj za pomocą konsoli menedżera pakietów lub interfejsu CLI .NET:

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Po zainstalowaniu pakietu można od razu zacząć generować pliki PDF — podczas bezpłatnego okresu próbnego nie jest wymagany żaden plik konfiguracyjny ani klucz API. Aby uzyskać licencję produkcyjną, odwiedź stronę licencyjną IronPDF i wybierz plan odpowiadający Twojemu modelowi wdrożenia.

Punktem wyjścia dla wszystkich renderowań jest ChromePdfRenderer. Poniższy fragment kodu przedstawia minimalny kod potrzebny do przekształcenia dynamicznego ciągu znaków HTML w zapisany plik PDF:

using IronPdf;

var renderer = new ChromePdfRenderer();

var customerName = "Alexandra Chen";
var orderNumber = "ORD-2025-001";
var totalAmount = 1499.99m;

var html = $"""
    <h1>Order Confirmation</h1>
    <p>Dear {customerName},</p>
    <p>Thank you for your order #{orderNumber}.</p>
    <p>Total amount: ${totalAmount:F2}</p>
    <p>Your order will be processed within 24 hours.</p>
    """;

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("order-confirmation.pdf");

// Stream the bytes directly in a web response if needed
byte[] pdfBytes = pdf.BinaryData;

using IronPdf;

var renderer = new ChromePdfRenderer();

var customerName = "Alexandra Chen";
var orderNumber = "ORD-2025-001";
var totalAmount = 1499.99m;

var html = $"""
    <h1>Order Confirmation</h1>
    <p>Dear {customerName},</p>
    <p>Thank you for your order #{orderNumber}.</p>
    <p>Total amount: ${totalAmount:F2}</p>
    <p>Your order will be processed within 24 hours.</p>
    """;

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("order-confirmation.pdf");

// Stream the bytes directly in a web response if needed
byte[] pdfBytes = pdf.BinaryData;

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

Dim customerName As String = "Alexandra Chen"
Dim orderNumber As String = "ORD-2025-001"
Dim totalAmount As Decimal = 1499.99D

Dim html As String = $"
    <h1>Order Confirmation</h1>
    <p>Dear {customerName},</p>
    <p>Thank you for your order #{orderNumber}.</p>
    <p>Total amount: ${totalAmount:F2}</p>
    <p>Your order will be processed within 24 hours.</p>
    "

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("order-confirmation.pdf")

' Stream the bytes directly in a web response if needed
Dim pdfBytes As Byte() = pdf.BinaryData

ChromePdfRenderer wewnętrznie obsługuje całą złożoność renderowania. Interpolacja ciągów znaków ($"""...""") umieszcza zmienne C# w kodzie HTML w momencie wywołania, dzięki czemu szablony pozostają czytelne, a w prostych przypadkach nie jest potrzebna specjalna biblioteka szablonów.

Pełne wskazówki dotyczące instalacji, w tym konfiguracji widoków MVC i projektów serwerowych Blazor, można znaleźć w dokumentacji IronPDF.

Jak stosować generowanie plików PDF na podstawie szablonów?

Generowanie oparte na szablonach oddziela projekt dokumentu od powiązania danych. Projektant tworzy układ HTML jednorazowo, umieszczając nazwane symbole zastępcze ({{TOKEN}}) w miejscach, gdzie powinny pojawić się wartości w czasie wykonywania, a aplikacja zastępuje te symbole przed renderowaniem. Jest to wzorzec zalecany w dyskusjach dotyczących generowania plików PDF na Stack Overflow w przypadku projektów, w których szablony zmieniają się częściej niż kod aplikacji.

using IronPdf;

// Reusable template -- stored in a file or database in production
var htmlTemplate = """
    <style>
        .invoice { font-family: Arial; max-width: 800px; margin: auto; }
        .header  { background: #f0f0f0; padding: 20px; }
        .label   { font-weight: bold; }
    </style>
    <div class='invoice'>
        <div class='header'>
            <h2>Invoice #{{INVOICE_NUMBER}}</h2>
            <p>Date: {{INVOICE_DATE}}</p>
        </div>
        <p>Bill to: {{CUSTOMER_NAME}}</p>
        <p class='label'>Amount due: ${{TOTAL_AMOUNT}}</p>
    </div>
    """;

var invoiceHtml = htmlTemplate
    .Replace("{{INVOICE_NUMBER}}", "INV-2025-1234")
    .Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy"))
    .Replace("{{CUSTOMER_NAME}}", "TechCorp Industries")
    .Replace("{{TOTAL_AMOUNT}}", "5,750.00");

var renderer = new ChromePdfRenderer();

renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText    = "Invoice",
    DrawDividerLine = true
};

var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);
pdf.SaveAs("invoice.pdf");

using IronPdf;

// Reusable template -- stored in a file or database in production
var htmlTemplate = """
    <style>
        .invoice { font-family: Arial; max-width: 800px; margin: auto; }
        .header  { background: #f0f0f0; padding: 20px; }
        .label   { font-weight: bold; }
    </style>
    <div class='invoice'>
        <div class='header'>
            <h2>Invoice #{{INVOICE_NUMBER}}</h2>
            <p>Date: {{INVOICE_DATE}}</p>
        </div>
        <p>Bill to: {{CUSTOMER_NAME}}</p>
        <p class='label'>Amount due: ${{TOTAL_AMOUNT}}</p>
    </div>
    """;

var invoiceHtml = htmlTemplate
    .Replace("{{INVOICE_NUMBER}}", "INV-2025-1234")
    .Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy"))
    .Replace("{{CUSTOMER_NAME}}", "TechCorp Industries")
    .Replace("{{TOTAL_AMOUNT}}", "5,750.00");

var renderer = new ChromePdfRenderer();

renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText    = "Invoice",
    DrawDividerLine = true
};

var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);
pdf.SaveAs("invoice.pdf");

Imports IronPdf

' Reusable template -- stored in a file or database in production
Dim htmlTemplate As String = "
    <style>
        .invoice { font-family: Arial; max-width: 800px; margin: auto; }
        .header  { background: #f0f0f0; padding: 20px; }
        .label   { font-weight: bold; }
    </style>
    <div class='invoice'>
        <div class='header'>
            <h2>Invoice #{{INVOICE_NUMBER}}</h2>
            <p>Date: {{INVOICE_DATE}}</p>
        </div>
        <p>Bill to: {{CUSTOMER_NAME}}</p>
        <p class='label'>Amount due: ${{TOTAL_AMOUNT}}</p>
    </div>
    "

Dim invoiceHtml As String = htmlTemplate _
    .Replace("{{INVOICE_NUMBER}}", "INV-2025-1234") _
    .Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy")) _
    .Replace("{{CUSTOMER_NAME}}", "TechCorp Industries") _
    .Replace("{{TOTAL_AMOUNT}}", "5,750.00")

Dim renderer As New ChromePdfRenderer()

renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
    .CenterText = "Invoice",
    .DrawDividerLine = True
}

Dim pdf = renderer.RenderHtmlAsPdf(invoiceHtml)
pdf.SaveAs("invoice.pdf")

Tokeny ({{...}}) zaznaczają dokładnie miejsca, w których dane są wprowadzane do dokumentu, dzięki czemu szablony są czytelne dla osób niebędących programistami. Przechowywanie szablonów jako plików zewnętrznych oznacza, że projektant może aktualizować układ bez ingerencji w kod aplikacji. Aby uzyskać bardziej szczegółowe omówienie tego wzorca, zapoznaj się z samouczkiem dotyczącym szablonu IronPDF.

Jak programowo tworzyć pliki PDF na podstawie danych?

Gdy treść dokumentu zależy od pętli, agregacji lub formatowania warunkowego, tworzenie ciągu HTML w kodzie zapewnia największą kontrolę. Takie podejście jest powszechne w sprawozdawczości finansowej i operacyjnej, gdzie liczba wierszy jest nieznana w momencie kompilacji. Pozwala to również na stosowanie reguł formatowania bezpośrednio w języku C#, zamiast osadzania ich w statycznym szablonie.

using IronPdf;
using System.Text;

var orderItems = new[]
{
    new { Product = "Premium License",  Quantity = 5, Price = 399.00m },
    new { Product = "Support Package",  Quantity = 1, Price = 299.00m },
    new { Product = "Training Session", Quantity = 2, Price = 150.00m }
};

var sb = new StringBuilder();
sb.Append("<h2>Order Summary</h2>");
sb.Append("<table style='width:100%; border-collapse:collapse;'>");
sb.Append("<tr style='background:#333; color:white;'>");
sb.Append("<th style='padding:10px;'>Product</th><th>Qty</th><th>Unit Price</th><th>Total</th>");
sb.Append("</tr>");

decimal grandTotal = 0;
foreach (var item in orderItems)
{
    var lineTotal = item.Quantity * item.Price;
    grandTotal += lineTotal;
    sb.Append($"""
        <tr>
            <td style='padding:10px;'>{item.Product}</td>
            <td style='text-align:center;'>{item.Quantity}</td>
            <td style='text-align:right;'>${item.Price:F2}</td>
            <td style='text-align:right;'>${lineTotal:F2}</td>
        </tr>
        """);
}

sb.Append($"""
    <tr style='font-weight:bold; background:#f0f0f0;'>
        <td colspan='3' style='padding:10px; text-align:right;'>Grand total:</td>
        <td style='text-align:right; padding:10px;'>${grandTotal:F2}</td>
    </tr>
    """);
sb.Append("</table>");

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(sb.ToString());

pdf.SaveAs("order-summary.pdf");

// Get bytes for a web download response
byte[] pdfData = pdf.BinaryData;

using IronPdf;
using System.Text;

var orderItems = new[]
{
    new { Product = "Premium License",  Quantity = 5, Price = 399.00m },
    new { Product = "Support Package",  Quantity = 1, Price = 299.00m },
    new { Product = "Training Session", Quantity = 2, Price = 150.00m }
};

var sb = new StringBuilder();
sb.Append("<h2>Order Summary</h2>");
sb.Append("<table style='width:100%; border-collapse:collapse;'>");
sb.Append("<tr style='background:#333; color:white;'>");
sb.Append("<th style='padding:10px;'>Product</th><th>Qty</th><th>Unit Price</th><th>Total</th>");
sb.Append("</tr>");

decimal grandTotal = 0;
foreach (var item in orderItems)
{
    var lineTotal = item.Quantity * item.Price;
    grandTotal += lineTotal;
    sb.Append($"""
        <tr>
            <td style='padding:10px;'>{item.Product}</td>
            <td style='text-align:center;'>{item.Quantity}</td>
            <td style='text-align:right;'>${item.Price:F2}</td>
            <td style='text-align:right;'>${lineTotal:F2}</td>
        </tr>
        """);
}

sb.Append($"""
    <tr style='font-weight:bold; background:#f0f0f0;'>
        <td colspan='3' style='padding:10px; text-align:right;'>Grand total:</td>
        <td style='text-align:right; padding:10px;'>${grandTotal:F2}</td>
    </tr>
    """);
sb.Append("</table>");

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(sb.ToString());

pdf.SaveAs("order-summary.pdf");

// Get bytes for a web download response
byte[] pdfData = pdf.BinaryData;

Imports IronPdf
Imports System.Text

Dim orderItems = New() {
    New With {.Product = "Premium License", .Quantity = 5, .Price = 399.0D},
    New With {.Product = "Support Package", .Quantity = 1, .Price = 299.0D},
    New With {.Product = "Training Session", .Quantity = 2, .Price = 150.0D}
}

Dim sb = New StringBuilder()
sb.Append("<h2>Order Summary</h2>")
sb.Append("<table style='width:100%; border-collapse:collapse;'>")
sb.Append("<tr style='background:#333; color:white;'>")
sb.Append("<th style='padding:10px;'>Product</th><th>Qty</th><th>Unit Price</th><th>Total</th>")
sb.Append("</tr>")

Dim grandTotal As Decimal = 0
For Each item In orderItems
    Dim lineTotal = item.Quantity * item.Price
    grandTotal += lineTotal
    sb.Append($"
        <tr>
            <td style='padding:10px;'>{item.Product}</td>
            <td style='text-align:center;'>{item.Quantity}</td>
            <td style='text-align:right;'>${item.Price:F2}</td>
            <td style='text-align:right;'>${lineTotal:F2}</td>
        </tr>
        ")
Next

sb.Append($"
    <tr style='font-weight:bold; background:#f0f0f0;'>
        <td colspan='3' style='padding:10px; text-align:right;'>Grand total:</td>
        <td style='text-align:right; padding:10px;'>${grandTotal:F2}</td>
    </tr>
    ")
sb.Append("</table>")

Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(sb.ToString())

pdf.SaveAs("order-summary.pdf")

' Get bytes for a web download response
Dim pdfData As Byte() = pdf.BinaryData

StringBuilder efektywnie obsługuje duże ciągi HTML. Pętla foreach rozszerza się na tyle wierszy, ile zapewnia źródło danych, a wykonywane obliczenie grandTotal pokazuje, jak logika biznesowa w naturalny sposób integruje się z konstrukcją HTML. W przypadku bardzo dużych zbiorów danych podejście to dobrze współgra z opcjami renderowania wielu stron w IronPDF.

Jak radzisz sobie z tabelami dynamicznymi, które zajmują wiele stron?

Raporty generowane z baz danych często zawierają nieprzewidywalną liczbę wierszy. Prawidłowe obsługiwanie automatycznych podziałów stron — bez dzielenia wiersza na pół — wymaga zastosowania określonych arkuszy CSS wraz z opcjami renderowania IronPDF. Zasada page-break-inside: avoid w połączeniu z prawidłową konfiguracją marginesów pozwala zachować każdy wiersz w niezmienionej postaci, gdy tabela rozciąga się na kilka stron.

using IronPdf;

var salesData = Enumerable.Range(1, 30).Select(i => new
{
    Month   = $"Month {i}",
    Revenue = 10_000 + (i * 500),
    Growth  = 2.5 + (i * 0.3)
});

var tableHtml = """
    <style>
        table { width: 100%; border-collapse: collapse; page-break-inside: auto; }
        th    { background: #2c3e50; color: white; padding: 12px; }
        td    { padding: 8px; border-bottom: 1px solid #ddd; }
        tr:nth-child(even) { background: #f9f9f9; }
        tr    { page-break-inside: avoid; page-break-after: auto; }
    </style>
    <h2>Sales Performance Report</h2>
    <table>
        <thead><tr><th>Period</th><th>Revenue</th><th>Growth %</th></tr></thead>
        <tbody>
    """;

foreach (var row in salesData)
{
    tableHtml += $"""
        <tr>
            <td>{row.Month}</td>
            <td>${row.Revenue:N0}</td>
            <td>{row.Growth:F1}%</td>
        </tr>
        """;
}

tableHtml += "</tbody></table>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize   = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop    = 40;
renderer.RenderingOptions.MarginBottom = 40;

renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "{page} of {total-pages}",
    FontSize   = 10
};

var pdf = renderer.RenderHtmlAsPdf(tableHtml);
pdf.SaveAs("sales-report.pdf");

using IronPdf;

var salesData = Enumerable.Range(1, 30).Select(i => new
{
    Month   = $"Month {i}",
    Revenue = 10_000 + (i * 500),
    Growth  = 2.5 + (i * 0.3)
});

var tableHtml = """
    <style>
        table { width: 100%; border-collapse: collapse; page-break-inside: auto; }
        th    { background: #2c3e50; color: white; padding: 12px; }
        td    { padding: 8px; border-bottom: 1px solid #ddd; }
        tr:nth-child(even) { background: #f9f9f9; }
        tr    { page-break-inside: avoid; page-break-after: auto; }
    </style>
    <h2>Sales Performance Report</h2>
    <table>
        <thead><tr><th>Period</th><th>Revenue</th><th>Growth %</th></tr></thead>
        <tbody>
    """;

foreach (var row in salesData)
{
    tableHtml += $"""
        <tr>
            <td>{row.Month}</td>
            <td>${row.Revenue:N0}</td>
            <td>{row.Growth:F1}%</td>
        </tr>
        """;
}

tableHtml += "</tbody></table>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize   = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop    = 40;
renderer.RenderingOptions.MarginBottom = 40;

renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "{page} of {total-pages}",
    FontSize   = 10
};

var pdf = renderer.RenderHtmlAsPdf(tableHtml);
pdf.SaveAs("sales-report.pdf");

Imports IronPdf

Dim salesData = Enumerable.Range(1, 30).Select(Function(i) New With {
    .Month = $"Month {i}",
    .Revenue = 10000 + (i * 500),
    .Growth = 2.5 + (i * 0.3)
})

Dim tableHtml As String = "
    <style>
        table { width: 100%; border-collapse: collapse; page-break-inside: auto; }
        th    { background: #2c3e50; color: white; padding: 12px; }
        td    { padding: 8px; border-bottom: 1px solid #ddd; }
        tr:nth-child(even) { background: #f9f9f9; }
        tr    { page-break-inside: avoid; page-break-after: auto; }
    </style>
    <h2>Sales Performance Report</h2>
    <table>
        <thead><tr><th>Period</th><th>Revenue</th><th>Growth %</th></tr></thead>
        <tbody>
    "

For Each row In salesData
    tableHtml += $"
        <tr>
            <td>{row.Month}</td>
            <td>${row.Revenue:N0}</td>
            <td>{row.Growth:F1}%</td>
        </tr>
        "
Next

tableHtml += "</tbody></table>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 40
renderer.RenderingOptions.MarginBottom = 40

renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
    .CenterText = "{page} of {total-pages}",
    .FontSize = 10
}

Dim pdf = renderer.RenderHtmlAsPdf(tableHtml)
pdf.SaveAs("sales-report.pdf")

{page} i {total-pages} to wbudowane tokeny IronPDF służące do automatycznego numerowania stopek. Marginesy zapewniają odpowiedni odstęp treści od krawędzi każdej strony, nadając gotowemu raportowi profesjonalny wygląd, nawet jeśli tabela zajmuje kilkadziesiąt stron.

Wskazówki dotyczące formatowania złożonych układów tabel, w tym scalonych komórek, można znaleźć w opisie opcji renderowania IronPDF.

Jak dodać treść warunkową do pliku PDF?

Wiele typów dokumentów zawiera sekcje, które powinny pojawiać się tylko wtedy, gdy spełnione są określone warunki — odznaka premium dla klientów z najwyższej półki, blok z rabatem w przypadku promocji, ostrzeżenie o zaległościach w płatnościach. Logika warunkowa języka C# odpowiada bezpośrednio temu wymaganiu, a ponieważ warunek jest oceniany przed utworzeniem ciągu HTML, w ostatecznym PDF nie ma pustych elementów zastępczych.

using IronPdf;

var customer = new
{
    Name           = "Global Tech Solutions",
    IsPremium      = true,
    HasDiscount    = true,
    DiscountPct    = 15,
    LoyaltyPoints  = 2500
};

var html = $"""<h2>Customer Profile: {customer.Name}</h2><div style='border:1px solid #ddd; padding:20px;'>""";

if (customer.IsPremium)
{
    html += """<div style='background:gold; padding:10px; margin-bottom:10px;'>PREMIUM MEMBER -- Exclusive benefits applied</div>""";
}

if (customer.HasDiscount)
{
    html += $"""<div style='background:#e8f5e9; padding:10px; margin-bottom:10px;'>Special discount: {customer.DiscountPct}% off all orders</div>""";
}

if (customer.LoyaltyPoints > 0)
{
    html += $"""<div style='background:#f3e5f5; padding:10px;'>Loyalty points balance: {customer.LoyaltyPoints:N0} points</div>""";
}

html += "</div>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("customer-profile.pdf");

using IronPdf;

var customer = new
{
    Name           = "Global Tech Solutions",
    IsPremium      = true,
    HasDiscount    = true,
    DiscountPct    = 15,
    LoyaltyPoints  = 2500
};

var html = $"""<h2>Customer Profile: {customer.Name}</h2><div style='border:1px solid #ddd; padding:20px;'>""";

if (customer.IsPremium)
{
    html += """<div style='background:gold; padding:10px; margin-bottom:10px;'>PREMIUM MEMBER -- Exclusive benefits applied</div>""";
}

if (customer.HasDiscount)
{
    html += $"""<div style='background:#e8f5e9; padding:10px; margin-bottom:10px;'>Special discount: {customer.DiscountPct}% off all orders</div>""";
}

if (customer.LoyaltyPoints > 0)
{
    html += $"""<div style='background:#f3e5f5; padding:10px;'>Loyalty points balance: {customer.LoyaltyPoints:N0} points</div>""";
}

html += "</div>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("customer-profile.pdf");

Imports IronPdf

Dim customer = New With {
    .Name = "Global Tech Solutions",
    .IsPremium = True,
    .HasDiscount = True,
    .DiscountPct = 15,
    .LoyaltyPoints = 2500
}

Dim html = $"<h2>Customer Profile: {customer.Name}</h2><div style='border:1px solid #ddd; padding:20px;'>"

If customer.IsPremium Then
    html += "<div style='background:gold; padding:10px; margin-bottom:10px;'>PREMIUM MEMBER -- Exclusive benefits applied</div>"
End If

If customer.HasDiscount Then
    html += $"<div style='background:#e8f5e9; padding:10px; margin-bottom:10px;'>Special discount: {customer.DiscountPct}% off all orders</div>"
End If

If customer.LoyaltyPoints > 0 Then
    html += $"<div style='background:#f3e5f5; padding:10px;'>Loyalty points balance: {customer.LoyaltyPoints:N0} points</div>"
End If

html += "</div>"

Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("customer-profile.pdf")

Ten sam wzór można zastosować do dowolnych treści opartych na regułach: zastrzeżeń prawnych dotyczących konkretnej jurysdykcji, sekcji promocyjnych wyświetlanych na podstawie wartości koszyka lub ostrzeżeń dotyczących bezpieczeństwa wyświetlanych na podstawie kategorii produktu. Powstały plik PDF zawiera dokładnie to, co powinien — nic więcej i nic mniej.

Jak renderować wykresy oparte na JavaScript w pliku PDF?

Nowoczesne pulpity nawigacyjne często wykorzystują biblioteki do tworzenia wykresów w JavaScript, takie jak Chart.js lub D3.js, do rysowania wykresów w czasie renderowania. IronPDF może wykonać kod JavaScript przed przechwyceniem strony, dzięki czemu wykres jest w pełni renderowany przed wykonaniem migawki PDF. Oznacza to, że nie potrzebujesz osobnej usługi zrzutów ekranu ani biblioteki do renderowania wykresów po stronie serwera.

using IronPdf;

var chartHtml = """
    <script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
    <canvas id='revenueChart' width='500' height='250'></canvas>
    <script>
        var ctx = document.getElementById('revenueChart').getContext('2d');
        new Chart(ctx, {
            type: 'bar',
            data: {
                labels: ['Q1', 'Q2', 'Q3', 'Q4'],
                datasets: [{
                    label: 'Revenue (thousands)',
                    data: [120, 195, 230, 285],
                    backgroundColor: '#3498db'
                }]
            },
            options: { animation: false }
        });
    </script>
    """;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1500);

var pdf = renderer.RenderHtmlAsPdf(chartHtml);
pdf.SaveAs("revenue-chart.pdf");

using IronPdf;

var chartHtml = """
    <script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
    <canvas id='revenueChart' width='500' height='250'></canvas>
    <script>
        var ctx = document.getElementById('revenueChart').getContext('2d');
        new Chart(ctx, {
            type: 'bar',
            data: {
                labels: ['Q1', 'Q2', 'Q3', 'Q4'],
                datasets: [{
                    label: 'Revenue (thousands)',
                    data: [120, 195, 230, 285],
                    backgroundColor: '#3498db'
                }]
            },
            options: { animation: false }
        });
    </script>
    """;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1500);

var pdf = renderer.RenderHtmlAsPdf(chartHtml);
pdf.SaveAs("revenue-chart.pdf");

Imports IronPdf

Dim chartHtml As String = "
    <script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
    <canvas id='revenueChart' width='500' height='250'></canvas>
    <script>
        var ctx = document.getElementById('revenueChart').getContext('2d');
        new Chart(ctx, {
            type: 'bar',
            data: {
                labels: ['Q1', 'Q2', 'Q3', 'Q4'],
                datasets: [{
                    label: 'Revenue (thousands)',
                    data: [120, 195, 230, 285],
                    backgroundColor: '#3498db'
                }]
            },
            options: { animation: false }
        });
    </script>
    "

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1500)

Dim pdf = renderer.RenderHtmlAsPdf(chartHtml)
pdf.SaveAs("revenue-chart.pdf")

EnableJavaScript = true uruchamia skrypt w silniku Chrome bez interfejsu graficznego. RenderDelay(1500) dodaje 1,5-sekundową pauzę po załadowaniu strony, dając czas na zakończenie asynchronicznego renderowania wykresu przed wykonaniem zrzutu ekranu. Ustawienie animation: false w opcjach Chart.js zapobiega przechwytywaniu animowanych klatek w trakcie przejścia.

Ta technika działa z każdą biblioteką JavaScript. Możesz przekazać dane po stronie serwera do bloku <script> za pomocą interpolacji ciągów znaków w języku C#, dzięki czemu każdy wykres odzwierciedla aktualne dane z bazy w momencie generowania. Więcej szczegółów na temat konfiguracji JavaScript można znaleźć w przewodniku renderowania JavaScript firmy IronPDF.

Jak wyeksportować i dostarczyć wygenerowany plik PDF?

Gdy RenderHtmlAsPdf zwróci obiekt PdfDocument, masz kilka opcji dostarczenia w zależności od typu aplikacji. Zapisywanie na dysku jest najprostszym podejściem i sprawdza się w przypadku zadań wsadowych wykonywanych w tle. W przypadku interfejsów API sieci Web i kontrolerów MVC przesyłanie strumieniowe bajtów bezpośrednio do odpowiedzi HTTP pozwala uniknąć tworzenia plików tymczasowych i utrzymuje porządek w systemie plików serwera.

using IronPdf;
using Microsoft.AspNetCore.Mvc;

// In an ASP.NET Core controller action:
public IActionResult DownloadInvoice(int orderId)
{
    var renderer = new ChromePdfRenderer();
    var html     = BuildInvoiceHtml(orderId);   // your data-binding method
    var pdf      = renderer.RenderHtmlAsPdf(html);

    return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
}

using IronPdf;
using Microsoft.AspNetCore.Mvc;

// In an ASP.NET Core controller action:
public IActionResult DownloadInvoice(int orderId)
{
    var renderer = new ChromePdfRenderer();
    var html     = BuildInvoiceHtml(orderId);   // your data-binding method
    var pdf      = renderer.RenderHtmlAsPdf(html);

    return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

' In an ASP.NET Core controller action:
Public Function DownloadInvoice(orderId As Integer) As IActionResult
    Dim renderer = New ChromePdfRenderer()
    Dim html = BuildInvoiceHtml(orderId)   ' your data-binding method
    Dim pdf = renderer.RenderHtmlAsPdf(html)

    Return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf")
End Function

pdf.BinaryData zwraca surowe bajty jako byte[], co odpowiada bezpośrednio wynikowi File() w .NET Core. Przeglądarka otrzymuje prawidłowy typ MIME (application/pdf) i wyświetla okno dialogowe pobierania z sensowną nazwą pliku.

Dodatkowe możliwości obejmują scalanie plików PDF, podpisy cyfrowe, format archiwizacji PDF/A, ochronę hasłem oraz wyodrębnianie tekstu i obrazów. Funkcje te działają na tym samym obiekcie PdfDocument zwracanym przez renderer, dzięki czemu można łączyć operacje bez tworzenia plików pośrednich.

Jakie są Twoje kolejne kroki?

Dynamiczne generowanie plików PDF w .NET sprowadza się do trzech elementów: ciągu znaków HTML, który zmienia się w zależności od danych, ChromePdfRenderer do konwersji tego ciągu znaków na plik PDF oraz mechanizmu dostarczania, który pasuje do danej aplikacji. IronPDF zajmuje się wszystkim pomiędzy — podziałami stron, nagłówkami i stopkami, wykonywaniem kodu JavaScript oraz kompatybilnością między platformami.

Aby przejść od czytania do tworzenia, zacznij od zainstalowania pakietu i uruchomienia jednego z powyższych przykładów na własnych danych:

dotnet add package IronPdf

dotnet add package IronPdf

Następnie zapoznaj się z dokumentacją IronPDF, aby uzyskać informacje na temat konfiguracji dla poszczególnych platform (Azure, Docker, Linux), zaawansowanych opcji renderowania oraz pełnej dokumentacji API. Gdy będziesz gotowy do wdrożenia, odwiedź stronę licencyjną, aby wybrać plan dostosowany do Twojej wielkości produkcji. Bezpłatna wersja próbna zapewnia pełny dostęp bez konieczności podawania danych karty kredytowej, dzięki czemu można sprawdzić działanie rozwiązania przed podjęciem ostatecznej decyzji.

Dodatkowe przewodniki, które dobrze współgrają z generowaniem dynamicznym:

• Generowanie pliku PDF z szablonu HTML w języku C#
• Konwersja adresu URL do formatu PDF
• Łączenie i dzielenie dokumentów PDF
• Dodawanie podpisów cyfrowych do plików PDF
• Zgodność z formatem PDF/A dla dokumentów archiwalnych