Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Korzystanie z IronPDF
  4. .NET Core Utwórz plik PDF
KORZYSTANIE Z IRONPDF

Jak tworzyć pliki PDF w .NET Core za pomocą IronPDF

Curtis Chau
Curtis Chau
Zaktualizowano:

IronPDF tworzy pliki PDF w aplikacjach .NET Core poprzez konwersję HTML do PDF przy użyciu silnika renderującego Chrome, obsługując CSS3, JavaScript, obrazy i złożone układy za pomocą prostego kodu C#.

Programowe tworzenie dokumentów PDF jest powszechnym wymaganiem w nowoczesnych aplikacjach internetowych. Niezależnie od tego, czy tworzysz faktury, raporty czy dowolny system oparty na dokumentach, wiedza na temat efektywnego tworzenia plików PDF w ASP.NET Core jest niezbędna. W tym samouczku omówiono najlepsze metody tworzenia plików PDF w .NET Core przy użyciu IronPDF — wydajnej biblioteki, która upraszcza generowanie plików PDF. Pełne szczegóły techniczne można znaleźć w oficjalnej dokumentacji.

IronPDF umożliwia programistom .NET Core tworzenie plików PDF przy użyciu prostego kodu HTML i CSS, eliminując skomplikowane ręczne operacje związane z rysowaniem plików PDF dzięki intuicyjnemu interfejsowi API i silnikowi renderowania. Biblioteka obsługuje różne środowiska wdrożeniowe, w tym Windows, Linux, macOS oraz platformy chmurowe, takie jak Azure i AWS Lambda. Silnik renderujący biblioteki oparty na przeglądarce Chrome zapewnia dokładną konwersję HTML do PDF z zachowaniem każdego piksela oraz pełną obsługę typów mediów ekranowych i PRINT CSS.

Jak rozpocząć generowanie plików PDF w .NET Core?

IronPDF to kompletna biblioteka PDF dla platformy .NET Core, która przekształca złożone procesy tworzenia plików PDF w proste operacje. W przeciwieństwie do tradycyjnych metod, które wymagają ręcznego rysowania elementów, IronPDF wykorzystuje znaczniki HTML i CSS do generowania plików PDF, które dokładnie odpowiadają Twoim wymaganiom projektowym. Biblioteka wykorzystuje silnik renderujący Chrome, co zapewnia konwersję HTML do PDF z idealną dokładnością pikselową. Takie podejście sprawia, że idealnie nadaje się ono zarówno do tworzenia nowych plików PDF, jak i do konwersji istniejących treści do formatu PDF.

Oceniając rozwiązania do generowania plików PDF dla .NET Core, programiści często porównują wiele opcji. IronPDF wyróżnia się na tle konkurentów, takich jak iText, Aspose i Syncfusion, z kilku powodów:

  • Najwyższa jakość renderowania: silnik oparty na Chrome zapewnia precyzyjne odwzorowanie HTML/CSS
  • Prostsze API: Twórz pliki PDF, korzystając z wiedzy o HTML zamiast skomplikowanych elementów podstawowych PDF
  • Obsługa wielu platform: natywne pliki binarne dla systemów Windows, Linux, macOS oraz platform chmurowych
  • Kompletne funkcje: od podstawowego tworzenia po zaawansowaną edycję i zabezpieczenia

Jak zainstalować IronPDF?

Aby rozpocząć tworzenie plików PDF w projekcie .NET Core, zainstaluj pakiet IronPDF NuGet. Użyj konsoli menedżera pakietów:

Install-Package IronPdf
Install-Package IronPdf
SHELL

Lub .NET CLI:

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Ta instalacja zapewnia natychmiastowy dostęp do funkcji generowania plików PDF dla aplikacji internetowych. W przypadku bardziej zaawansowanych scenariuszy instalacji zapoznaj się z dokumentacją pakietów NuGet lub sprawdź opcje wdrażania w Dockerze.

Jak utworzyć swój pierwszy dokument PDF?

Poniższy przykład pokazuje generowanie plików PDF z sformatowaną treścią przy użyciu funkcji konwersji ciągu HTML na PDF w IronPDF. Ta metoda jest idealna do tworzenia plików PDF z treści dynamicznych lub gdy trzeba wyeksportować HTML jako dokumenty PDF:

using IronPdf;

// Create a new ChromePdfRenderer
var renderer = new ChromePdfRenderer();

// Define HTML content with styling
var html = @"
    <html>
        <body style='font-family: Arial; margin: 40px;'>
            <h1>Hello World PDF Document</h1>
            <p>This is your first PDF file created with IronPDF!</p>
        </body>
    </html>";

// Generate PDF from HTML
var pdf = renderer.RenderHtmlAsPdf(html);

// Save the PDF document
pdf.SaveAs("output.pdf");
using IronPdf;

// Create a new ChromePdfRenderer
var renderer = new ChromePdfRenderer();

// Define HTML content with styling
var html = @"
    <html>
        <body style='font-family: Arial; margin: 40px;'>
            <h1>Hello World PDF Document</h1>
            <p>This is your first PDF file created with IronPDF!</p>
        </body>
    </html>";

// Generate PDF from HTML
var pdf = renderer.RenderHtmlAsPdf(html);

// Save the PDF document
pdf.SaveAs("output.pdf");
Imports IronPdf

' Create a new ChromePdfRenderer
Dim renderer As New ChromePdfRenderer()

' Define HTML content with styling
Dim html As String = "
    <html>
        <body style='font-family: Arial; margin: 40px;'>
            <h1>Hello World PDF Document</h1>
            <p>This is your first PDF file created with IronPDF!</p>
        </body>
    </html>"

' Generate PDF from HTML
Dim pdf = renderer.RenderHtmlAsPdf(html)

' Save the PDF document
pdf.SaveAs("output.pdf")
$vbLabelText   $csharpLabel

Ten kod tworzy nowy dokument PDF poprzez renderowanie treści HTML. ChromePdfRenderer obsługuje konwersję, zapewniając zachowanie spójnego formatowania dokumentów PDF. Można również zapisywać pliki PDF w strumieniach pamięci dla aplikacji internetowych, które zwracają plik wbudowany, zamiast zapisywać go na dysku.

Zrozumienie podstawowych komponentów pomoże Ci efektywnie korzystać z IronPDF:

  • ChromePdfRenderer: Główny silnik renderujący, który konwertuje HTML na PDF
  • PdfDocument: Reprezentuje dokument PDF do edycji
  • RenderingOptions: Kontroluje układ, marginesy, nagłówki i inne ustawienia
  • SecuritySettings: Zarządza hasłami, uprawnieniami i szyfrowaniem

Wykorzystanie HTML do tworzenia plików PDF oferuje znaczące korzyści w porównaniu z tradycyjnymi interfejsami API PDF. Programiści mogą wykorzystać posiadane umiejętności w zakresie HTML/CSS, frameworki CSS działają w naturalny sposób, JavaScript renderuje się przed konwersją, a zapytania o media dostosowują się do wymiarów pliku PDF. Aktualizacja treści pliku PDF wymaga jedynie zmiany szablonu HTML.

Przeglądarka PDF wyświetlająca prosty dokument

IronPDF ChromePdfRenderer creating Hello World PDF document with Arial font styling in .NET Core

Wygenerowany plik PDF pokazuje, jak IronPDF potrafi zamienić HTML ze stylami CSS w profesjonalny dokument PDF.

Jak przekonwertować HTML na PDF z zaawansowanymi układami?

IronPDF doskonale radzi sobie z konwersją złożonych stron internetowych i treści HTML na profesjonalne pliki PDF. Funkcja konwersji HTML do PDF obsługuje nowoczesny CSS3, JavaScript oraz responsywne projekty. Biblioteka obsługuje czcionki internetowe, układy Bootstrap i Flexbox, a nawet frameworki JavaScript. Poniższy kod pokazuje, jak utworzyć dokument PDF zawierający tabele, obrazy i elementy stylizowane — wraz z precyzyjną kontrolą układu:

using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure rendering options
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;

// Enable JavaScript for dynamic content
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);

// Set viewport and CSS media type
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

var html = @"
    <html>
    <head>
        <style>
            table { width: 100%; border-collapse: collapse; }
            th, td { padding: 10px; border: 1px solid #ddd; }
            th { background-color: #f2f2f2; }
        </style>
    </head>
    <body>
        <h2>Sales Report</h2>
        <table>
            <tr><th>Product</th><th>Quantity</th><th>Total</th></tr>
            <tr><td>Software License</td><td>10</td><td>$500</td></tr>
        </table>
    </body>
    </html>";

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure rendering options
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;

// Enable JavaScript for dynamic content
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);

// Set viewport and CSS media type
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

var html = @"
    <html>
    <head>
        <style>
            table { width: 100%; border-collapse: collapse; }
            th, td { padding: 10px; border: 1px solid #ddd; }
            th { background-color: #f2f2f2; }
        </style>
    </head>
    <body>
        <h2>Sales Report</h2>
        <table>
            <tr><th>Product</th><th>Quantity</th><th>Total</th></tr>
            <tr><td>Software License</td><td>10</td><td>$500</td></tr>
        </table>
    </body>
    </html>";

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");
Imports IronPdf

Dim renderer = New ChromePdfRenderer()

' Configure rendering options
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25

' Enable JavaScript for dynamic content
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1000)

' Set viewport and CSS media type
renderer.RenderingOptions.ViewPortWidth = 1024
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

Dim html As String = "
    <html>
    <head>
        <style>
            table { width: 100%; border-collapse: collapse; }
            th, td { padding: 10px; border: 1px solid #ddd; }
            th { background-color: #f2f2f2; }
        </style>
    </head>
    <body>
        <h2>Sales Report</h2>
        <table>
            <tr><th>Product</th><th>Quantity</th><th>Total</th></tr>
            <tr><td>Software License</td><td>10</td><td>$500</td></tr>
        </table>
    </body>
    </html>"

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("report.pdf")
$vbLabelText   $csharpLabel

Silnik IronPDF dla przeglądarki Chrome obsługuje szeroki zakres funkcji CSS: Flexbox, CSS Grid, elementy float, pozycjonowanie, transformacje CSS3, przejścia, animacje, czcionki internetowe, czcionki zmienne, zapytania o media specyficzne dla druku oraz selektory pseudoelementów. Można również ustawić niestandardowe marginesy i rozmiary papieru oraz zarządzać czcionkami w celu obsługi języków międzynarodowych.

PDF viewer displaying a professionally formatted Sales Report with a table showing Software License product data including quantity (10) and total ($500), demonstrating IronPDF's advanced table formatting and CSS styling capabilities in .NET Core applications

Advanced IronPDF table rendering with CSS styling showing sales report data in formatted PDF

Zaawansowane formatowanie tabel pokazuje możliwości renderowania CSS w IronPDF w przypadku profesjonalnych dokumentów biznesowych.

Jak zintegrować generowanie plików PDF w ASP.NET Core?

Integracja generowania plików PDF w ASP.NET Core MVC jest prosta. IronPDF integruje się z aplikacjami ASP.NET Core MVC, Razor Pages i Blazor Server. Oto kompletna implementacja pokazująca działanie akcji kontrolera i minimalnego punktu końcowego API współpracujących ze sobą:

using Microsoft.AspNetCore.Mvc;
using IronPdf;

// --- MVC Controller approach ---
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();

// Minimal API endpoint
app.MapGet("/api/pdf/{id}", async (int id) =>
{
    var renderer = new ChromePdfRenderer();
    var html = $"<h1>Invoice #{id}</h1><p>Thank you for your purchase!</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf");
});

app.Run();

// --- MVC Controller ---
public class DocumentController : Controller
{
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<h1>Invoice</h1><p>Thank you for your purchase!</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        return File(pdf.BinaryData, "application/pdf", "document.pdf");
    }
}
using Microsoft.AspNetCore.Mvc;
using IronPdf;

// --- MVC Controller approach ---
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();

// Minimal API endpoint
app.MapGet("/api/pdf/{id}", async (int id) =>
{
    var renderer = new ChromePdfRenderer();
    var html = $"<h1>Invoice #{id}</h1><p>Thank you for your purchase!</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf");
});

app.Run();

// --- MVC Controller ---
public class DocumentController : Controller
{
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<h1>Invoice</h1><p>Thank you for your purchase!</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        return File(pdf.BinaryData, "application/pdf", "document.pdf");
    }
}
Imports Microsoft.AspNetCore.Mvc
Imports IronPdf

' --- MVC Controller approach ---
Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()
Dim app = builder.Build()

' Minimal API endpoint
app.MapGet("/api/pdf/{id}", Async Function(id As Integer)
                                  Dim renderer = New ChromePdfRenderer()
                                  Dim html = $"<h1>Invoice #{id}</h1><p>Thank you for your purchase!</p>"
                                  Dim pdf = renderer.RenderHtmlAsPdf(html)
                                  Return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf")
                              End Function)

app.Run()

' --- MVC Controller ---
Public Class DocumentController
    Inherits Controller

    Public Function GeneratePdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<h1>Invoice</h1><p>Thank you for your purchase!</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        Return File(pdf.BinaryData, "application/pdf", "document.pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

Metoda kontrolera generuje dokument PDF i zwraca go jako plik do pobrania, co idealnie nadaje się do przetwarzania po stronie serwera. W przypadku bardziej złożonych scenariuszy warto rozważyć konwersję adresów URL do formatu PDF w celu bezpośredniego renderowania aktywnych stron internetowych do plików PDF.

Aplikacje Enterprise wymagają niezawodnego generowania plików PDF, które pasuje do ich istniejącej infrastruktury. IronPDF obsługuje tysiące równoczesnych żądań dotyczących plików PDF, generuje poufne dokumenty po stronie serwera, współpracuje z wstrzykiwaniem zależności i oprogramowaniem pośredniczącym oraz wdraża się w usłudze Azure App Service lub AWS. Postępuj zgodnie z poniższymi wytycznymi dotyczącymi generowania plików PDF gotowych do użycia w środowisku produkcyjnym: używaj wstrzykiwania zależności poprzez rejestrację usług IronPDF w kodzie startowym, wdrażaj buforowanie często generowanych plików PDF, obsługuj błędy w sposób płynny z opcjami awaryjnymi oraz zabezpiecz wrażliwe dane za pomocą haseł i uprawnień do plików PDF.

Przeglądarka plików PDF wyświetlająca dokument faktury z nagłówkiem

ASP.NET Core controller generating invoice PDF with IronPDF showing thank you message

Plik PDF wygenerowany przez kontroler pokazuje płynną integrację z aplikacjami internetowymi ASP.NET Core.

Jak dodawać nagłówki, stopki i łączyć dokumenty?

IronPDF obsługuje wiele zaawansowanych funkcji do tworzenia plików PDF. Możesz dodawać nagłówki i stopki, wstawiać numery stron oraz łączyć wiele plików PDF. Biblioteka obsługuje również znaki wodne, podpisy cyfrowe, zakładki, stemplowanie tekstu i obrazów oraz tworzenie spisu treści:

using IronPdf;

var renderer = new ChromePdfRenderer();

// Add text header and footer
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText = "Company Report",
    DrawDividerLine = true
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "Page {page} of {total-pages}",
    DrawDividerLine = true
};

// Add HTML-based branded header
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align: center'><img src='logo.png' /></div>",
    Height = 30
};

renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;

var html = "<h1>Annual Report</h1><p>Content goes here...</p>";
var mainPdf = renderer.RenderHtmlAsPdf(html);

// Merge multiple PDFs
var coverPdf = renderer.RenderHtmlAsPdf("<p>Cover Page</p>");
var merged = PdfDocument.Merge(coverPdf, mainPdf);

// Apply security
merged.SecuritySettings.SetPassword("user-password");
merged.SecuritySettings.AllowUserPrinting = true;
merged.SecuritySettings.AllowUserCopyPasteContent = false;

merged.SaveAs("report-with-header.pdf");
using IronPdf;

var renderer = new ChromePdfRenderer();

// Add text header and footer
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText = "Company Report",
    DrawDividerLine = true
};
renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "Page {page} of {total-pages}",
    DrawDividerLine = true
};

// Add HTML-based branded header
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align: center'><img src='logo.png' /></div>",
    Height = 30
};

renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;

var html = "<h1>Annual Report</h1><p>Content goes here...</p>";
var mainPdf = renderer.RenderHtmlAsPdf(html);

// Merge multiple PDFs
var coverPdf = renderer.RenderHtmlAsPdf("<p>Cover Page</p>");
var merged = PdfDocument.Merge(coverPdf, mainPdf);

// Apply security
merged.SecuritySettings.SetPassword("user-password");
merged.SecuritySettings.AllowUserPrinting = true;
merged.SecuritySettings.AllowUserCopyPasteContent = false;

merged.SaveAs("report-with-header.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Add text header and footer
renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
    .CenterText = "Company Report",
    .DrawDividerLine = True
}
renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
    .CenterText = "Page {page} of {total-pages}",
    .DrawDividerLine = True
}

' Add HTML-based branded header
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align: center'><img src='logo.png' /></div>",
    .Height = 30
}

renderer.RenderingOptions.MarginTop = 50
renderer.RenderingOptions.MarginBottom = 50

Dim html As String = "<h1>Annual Report</h1><p>Content goes here...</p>"
Dim mainPdf As PdfDocument = renderer.RenderHtmlAsPdf(html)

' Merge multiple PDFs
Dim coverPdf As PdfDocument = renderer.RenderHtmlAsPdf("<p>Cover Page</p>")
Dim merged As PdfDocument = PdfDocument.Merge(coverPdf, mainPdf)

' Apply security
merged.SecuritySettings.SetPassword("user-password")
merged.SecuritySettings.AllowUserPrinting = True
merged.SecuritySettings.AllowUserCopyPasteContent = False

merged.SaveAs("report-with-header.pdf")
$vbLabelText   $csharpLabel

Te przykłady pokazują, jak nadać tekstowi profesjonalny charakter i połączyć wiele plików w jeden dokument. Kluczowe funkcje ulepszające profesjonalne pliki PDF obejmują: nagłówki/stopki zapewniające spójność marki, numery stron ułatwiające nawigację po wielostronicowych dokumentach, znaki wodne zapewniające bezpieczeństwo i identyfikację wersji roboczej, zakładki w długich dokumentach oraz automatyczne generowanie spisu treści. Możesz również zapoznać się z opcjami orientacji i obracania stron, kompresji plików PDF lub dokumentów zgodnych ze standardem PDF/A przeznaczonych do długoterminowej archiwizacji.

Dokument PDF przedstawiający profesjonalny szablon raportu rocznego z nagłówkiem

Professional PDF with custom headers and footers created using IronPDF TextHeaderFooter

Profesjonalne nagłówki i stopki poprawiają wygląd dokumentu i ułatwiają nawigację.

Jak tworzyć interaktywne formularze PDF?

IronPDF umożliwia tworzenie interaktywnych formularzy PDF z różnymi polami wprowadzania danych — polami tekstowymi, polami wyboru, przyciskami opcji i listami rozwijanymi. Można również programowo wypełniać i edytować istniejące formularze PDF. Biblioteka obsługuje wyodrębnianie danych z formularzy i może spłaszczać formularze, aby uniemożliwić ich edycję:

using IronPdf;
using System.IO;

// Create a form from HTML
var html = @"
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .form-container { width: 400px; padding: 20px; border: 1px solid #ccc; border-radius: 8px; }
        .form-group { margin-bottom: 15px; }
        label { display: block; margin-bottom: 5px; font-weight: bold; color: #333; }
        input[type='text'], textarea { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 4px; box-sizing: border-box; }
        textarea { height: 100px; resize: vertical; }
    </style>
</head>
<body>
    <div class='form-container'>
        <h2>Document Generation Test Form</h2>
        <form>
            <div class='form-group'>
                <label for='fullName'>Full Name:</label>
                <input type='text' id='fullName' name='fullName'>
            </div>
            <div class='form-group'>
                <label for='comments'>Comments/Feedback:</label>
                <textarea id='comments' name='comments' placeholder='Type your feedback here...'></textarea>
            </div>
            <div class='form-group'>
                <input type='checkbox' id='agree' name='agree'>
                <label for='agree'>I agree to the terms and conditions.</label>
            </div>
            <button style='padding: 10px 15px; background-color: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer;'>
                Submit
            </button>
        </form>
    </div>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("form.pdf");

// Read back and process form data
var loadedPdf = new PdfDocument("form.pdf");
var fullName = loadedPdf.Form.FindFormField("fullName").Value;
Console.WriteLine($"Full Name: {fullName}");

// Flatten form to prevent further editing
loadedPdf.Form.Flatten();
loadedPdf.SaveAs("processed-form.pdf");
using IronPdf;
using System.IO;

// Create a form from HTML
var html = @"
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .form-container { width: 400px; padding: 20px; border: 1px solid #ccc; border-radius: 8px; }
        .form-group { margin-bottom: 15px; }
        label { display: block; margin-bottom: 5px; font-weight: bold; color: #333; }
        input[type='text'], textarea { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 4px; box-sizing: border-box; }
        textarea { height: 100px; resize: vertical; }
    </style>
</head>
<body>
    <div class='form-container'>
        <h2>Document Generation Test Form</h2>
        <form>
            <div class='form-group'>
                <label for='fullName'>Full Name:</label>
                <input type='text' id='fullName' name='fullName'>
            </div>
            <div class='form-group'>
                <label for='comments'>Comments/Feedback:</label>
                <textarea id='comments' name='comments' placeholder='Type your feedback here...'></textarea>
            </div>
            <div class='form-group'>
                <input type='checkbox' id='agree' name='agree'>
                <label for='agree'>I agree to the terms and conditions.</label>
            </div>
            <button style='padding: 10px 15px; background-color: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer;'>
                Submit
            </button>
        </form>
    </div>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("form.pdf");

// Read back and process form data
var loadedPdf = new PdfDocument("form.pdf");
var fullName = loadedPdf.Form.FindFormField("fullName").Value;
Console.WriteLine($"Full Name: {fullName}");

// Flatten form to prevent further editing
loadedPdf.Form.Flatten();
loadedPdf.SaveAs("processed-form.pdf");
Imports IronPdf
Imports System.IO

' Create a form from HTML
Dim html As String = "
<!DOCTYPE html>
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .form-container { width: 400px; padding: 20px; border: 1px solid #ccc; border-radius: 8px; }
        .form-group { margin-bottom: 15px; }
        label { display: block; margin-bottom: 5px; font-weight: bold; color: #333; }
        input[type='text'], textarea { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 4px; box-sizing: border-box; }
        textarea { height: 100px; resize: vertical; }
    </style>
</head>
<body>
    <div class='form-container'>
        <h2>Document Generation Test Form</h2>
        <form>
            <div class='form-group'>
                <label for='fullName'>Full Name:</label>
                <input type='text' id='fullName' name='fullName'>
            </div>
            <div class='form-group'>
                <label for='comments'>Comments/Feedback:</label>
                <textarea id='comments' name='comments' placeholder='Type your feedback here...'></textarea>
            </div>
            <div class='form-group'>
                <input type='checkbox' id='agree' name='agree'>
                <label for='agree'>I agree to the terms and conditions.</label>
            </div>
            <button style='padding: 10px 15px; background-color: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer;'>
                Submit
            </button>
        </form>
    </div>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = True
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("form.pdf")

' Read back and process form data
Dim loadedPdf As New PdfDocument("form.pdf")
Dim fullName As String = loadedPdf.Form.FindFormField("fullName").Value
Console.WriteLine($"Full Name: {fullName}")

' Flatten form to prevent further editing
loadedPdf.Form.Flatten()
loadedPdf.SaveAs("processed-form.pdf")
$vbLabelText   $csharpLabel

W ten sposób powstaje interaktywny plik PDF z polami formularza, które użytkownicy mogą wypełnić, idealny do aplikacji wymagających wprowadzania danych przez użytkownika. Interaktywne pliki PDF zaspokajają kluczowe potrzeby biznesowe: gromadzenie informacji bez formularzy internetowych, możliwość pracy w trybie offline dla użytkowników bez dostępu do Internetu, zgodność z przepisami dzięki podpisanym formularzom oraz znane interfejsy PDF, które skracają czas szkolenia.

Bezpieczna obsługa formularzy wymaga szczególnej uwagi. Zawsze należy weryfikować i oczyszczać wszystkie dane formularzy, ograniczać edycję pól formularzy za pomocą kontroli dostępu, rejestrować wszystkie przesłane formularze na potrzeby ścieżek audytu, chronić poufne dane formularzy za pomocą szyfrowania oraz weryfikować autentyczność formularzy za pomocą podpisów cyfrowych.

Interaktywny formularz PDF przedstawiający formularz testowy generowania dokumentów z polami tekstowymi do wypełnienia dla imienia i nazwiska oraz komentarzy/opinii, interaktywnym polem wyboru do wyrażenia zgody na warunki oraz niebieskim przyciskiem przesyłania, demonstrujący pełne możliwości tworzenia formularzy przez IronPDF

IronPDF interactive form with text fields, checkbox, and button demonstrating form creation

Formularze interaktywne umożliwiają gromadzenie danych bezpośrednio w dokumentach PDF.

Jak radzisz sobie z wydajnością i obsługą błędów w środowisku produkcyjnym?

Podczas generowania plików PDF w środowisku produkcyjnym należy wdrożyć odpowiednią obsługę błędów i rozważyć optymalizację wydajności. IronPDF zapewnia obsługę asynchroniczności i wielowątkowości w scenariuszach wymagających przetwarzania dużych ilości danych. Należy również wdrożyć niestandardowe logowanie do celów debugowania i monitorowania. Tworzenie instancji rendererów wiąże się z obciążeniem, dlatego niezbędne jest ich efektywne ponowne wykorzystanie. Poniższy przykład łączy obsługę błędów produkcyjnych z ponownym wykorzystaniem renderera:

using IronPdf;
using Microsoft.Extensions.Logging;

// Register a reusable renderer as a singleton in your DI container
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(500);

// Resilient generation with retry and exponential backoff
async Task<byte[]> GenerateWithRetry(string html, ILogger logger, int maxRetries = 3)
{
    for (int attempt = 1; attempt <= maxRetries; attempt++)
    {
        try
        {
            renderer.RenderingOptions.Timeout = 60;
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));
            pdf.SecuritySettings.MakePdfDocumentReadOnly();
            pdf.SecuritySettings.SetPassword("userPassword123");
            logger.LogInformation("PDF generated successfully on attempt {Attempt}", attempt);
            return pdf.BinaryData;
        }
        catch (Exception ex) when (attempt < maxRetries)
        {
            logger.LogWarning(ex, "PDF generation failed, attempt {Attempt} of {MaxRetries}", attempt, maxRetries);
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
    }
    throw new InvalidOperationException("Failed to generate PDF after retries");
}
using IronPdf;
using Microsoft.Extensions.Logging;

// Register a reusable renderer as a singleton in your DI container
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(500);

// Resilient generation with retry and exponential backoff
async Task<byte[]> GenerateWithRetry(string html, ILogger logger, int maxRetries = 3)
{
    for (int attempt = 1; attempt <= maxRetries; attempt++)
    {
        try
        {
            renderer.RenderingOptions.Timeout = 60;
            var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));
            pdf.SecuritySettings.MakePdfDocumentReadOnly();
            pdf.SecuritySettings.SetPassword("userPassword123");
            logger.LogInformation("PDF generated successfully on attempt {Attempt}", attempt);
            return pdf.BinaryData;
        }
        catch (Exception ex) when (attempt < maxRetries)
        {
            logger.LogWarning(ex, "PDF generation failed, attempt {Attempt} of {MaxRetries}", attempt, maxRetries);
            await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)));
        }
    }
    throw new InvalidOperationException("Failed to generate PDF after retries");
}
Imports IronPdf
Imports Microsoft.Extensions.Logging
Imports System.Threading.Tasks

' Register a reusable renderer as a singleton in your DI container
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(500)

' Resilient generation with retry and exponential backoff
Async Function GenerateWithRetry(html As String, logger As ILogger, Optional maxRetries As Integer = 3) As Task(Of Byte())
    For attempt As Integer = 1 To maxRetries
        Try
            renderer.RenderingOptions.Timeout = 60
            Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(html))
            pdf.SecuritySettings.MakePdfDocumentReadOnly()
            pdf.SecuritySettings.SetPassword("userPassword123")
            logger.LogInformation("PDF generated successfully on attempt {Attempt}", attempt)
            Return pdf.BinaryData
        Catch ex As Exception When attempt < maxRetries
            logger.LogWarning(ex, "PDF generation failed, attempt {Attempt} of {MaxRetries}", attempt, maxRetries)
            Await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt)))
        End Try
    Next
    Throw New InvalidOperationException("Failed to generate PDF after retries")
End Function
$vbLabelText   $csharpLabel

Zawsze należy weryfikować dane wejściowe i poprawnie obsługiwać wyjątki, aby zapewnić niezawodne generowanie plików PDF. Rozważ wdrożenie uprawnień i haseł do plików PDF w przypadku dokumentów wrażliwych, aby kontrolować prawa do drukowania, kopiowania i edycji.

Jakie wskaźniki monitorowania należy śledzić?

Monitoruj te kluczowe wskaźniki podczas generowania produkcyjnych plików PDF:

Kluczowe wskaźniki wydajności służące do monitorowania działania IronPDF
Metryka Cel Próg alertu
Czas generowania Śledzenie wydajności > 10 seconds
Wykorzystanie pamięci Optymalizacja zasobów > 500 MB per request
Wskaźnik błędów Monitorowanie niezawodności > 5% failure rate
Długość kolejki Planowanie wydajności > 100 pending
Rozmiar pliku Optymalizacja pamięci masowej > 50 MB average

Jak wdrażać i rozwiązywać problemy związane z generowaniem plików PDF na różnych platformach?

IronPDF obsługuje różne scenariusze wdrożenia na różnych platformach. Można wdrożyć na Azure Functions, AWS Lambda lub tradycyjnych serwerach IIS. Biblioteka obsługuje również wdrożenia w systemie Linux i może działać w kontenerach Docker dla architektur mikrousług. Różne podejścia do wdrażania oferują różne korzyści: kontenery Docker zapewniają spójność, Kubernetes umożliwia skalowanie horyzontalne, funkcje bezserwerowe zapewniają elastyczne skalowanie, a usługa IronPdfEngine zapewnia izolację procesów.

Jakie wymagania dotyczące platformy należy znać?

Każda platforma wymaga uwzględnienia specyficznych kwestii podczas wdrażania generowania plików PDF w środowisku .NET:

Wymagania dotyczące wdrożenia i rozwiązania dla IronPDF specyficzne dla danej platformy
Platforma Kluczowe wymagania Rozwiązanie
Linux Brakujące czcionki Zainstaluj pakiety czcionek za pomocą apt/yum
Docker Uprawnienia do plików Uruchom jako użytkownik bez uprawnień administratora
Azure App Service Katalog tymczasowy Skonfiguruj ścieżkę zapisu
AWS Lambda Uruchamianie na zimno Wykorzystaj zapewnioną współbieżność
macOS Podpisywanie kodu Zezwól na biblioteki niepodpisane w ustawieniach

Problemy z renderowaniem często wynikają z brakujących zasobów CSS lub JS, problemów z synchronizacją treści dynamicznych, brakujących czcionek serwerowych lub niezgodności CSS. Skuteczne debugowanie zaczyna się od włączenia szczegółowego logowania za pomocą renderer.LoggingMode = IronPdf.Logging.LoggingModes.All, zapisania pośredniego kodu HTML do kontroli oraz testowania z wyłączoną obsługą JavaScript w celu wyodrębnienia problemów z renderowaniem. Kluczowe znaczenie ma również zarządzanie pamięcią: należy zawsze usuwać obiekty PdfDocument, przetwarzać duże zadania w częściach oraz ustawiać odpowiednie limity pamięci kontenerów.

W przypadku wdrożeń w chmurze zapoznaj się z przewodnikiem wdrożeniowym platformy Azure oraz dokumentacją konfiguracyjną usługi AWS Lambda. Zgodnie z dokumentacją Microsoft .NET, wersja .NET 10 wprowadza dodatkowe ulepszenia wydajności, które uzupełniają własne optymalizacje IronPDF. Jeśli chodzi o szczegóły specyfikacji PDF, zasoby techniczne Stowarzyszenia PDF (PDF Association) dostarczają przydatnego kontekstu do zrozumienia wymagań zgodności z formatem PDF/A. Ponadto dokumentacja projektu Chromium firmy Google opisuje zachowania renderowania, które leżą u podstaw silnika HTML-to-PDF IronPDF.

Jakie są kolejne kroki w procesie generowania plików PDF?

IronPDF przekształca złożone zadanie tworzenia plików PDF w .NET Core w prosty i łatwy do opanowania proces. Od podstawowego tworzenia dokumentów po zaawansowane funkcje, takie jak formularze, obrazy i zarządzanie stronami, biblioteka ta zapewnia narzędzia do programowego generowania dokumentów PDF. Dzięki konwersji HTML do formatu PDF można szybko wczytać dane i wygenerować gotowe pliki. Obsługa różnych standardów PDF, funkcje ułatwień dostępu oraz kompletna dokumentacja sprawiają, że biblioteka ta nadaje się do zastosowań w przedsiębiorstwach.

Dlaczego IronPDF to właściwy wybór dla projektów .NET?

IronPDF wyróżnia się jako doskonały wybór do generowania plików PDF w środowisku .NET:

  • Gotowość do wdrożenia w Enterprise: Sprawdzone w praktyce w środowiskach produkcyjnych
  • Wieloplatformowość: Prawdziwa przenośność między systemami operacyjnymi
  • Aktywny rozwój: regularne aktualizacje z nowymi funkcjami
  • Wszechstronność formatów: Obsługuje konwersję plików DOCX do PDF, RTF do PDF, obrazów do PDF i wiele innych
  • Bogate możliwości manipulacji: wyodrębnianie tekstu i obrazów, rasteryzacja plików PDF do obrazów, redagowanie treści oraz dostęp do DOM pliku PDF

Jak zacząć już dziś?

Wykonaj poniższe kroki, aby rozpocząć proces generowania pliku PDF:

  1. Zainstaluj IronPDF: Dodaj za pomocą NuGet do swojego projektu .NET 10
  2. Wypróbuj podstawowe przykłady: zacznij od prostej konwersji HTML do PDF
  3. Poznaj zaawansowane funkcje: dodawanie formularzy, podpisów, ustawień zabezpieczeń
  4. Optymalizacja wydajności: wdrożenie buforowania, asynchroniczności i ponownego wykorzystania rendererów
  5. Wdrożenie do środowiska produkcyjnego: Wybierz odpowiednią strategię hostingu

Niezależnie od tego, czy tworzysz proste raporty, czy złożone, wielostronicowe dokumenty, intuicyjny interfejs API i wydajny silnik renderujący IronPDF sprawiają, że jest to praktyczny wybór dla programistów .NET. Już dziś zacznij tworzyć profesjonalne pliki PDF w swoich aplikacjach ASP.NET Core, korzystając z bezpłatnej wersji próbnej IronPDF. Chcesz dodać funkcje generowania plików PDF do swojej aplikacji? Zacznij korzystać z IronPDF i przekonaj się, jak proste może być tworzenie plików PDF. Aby uzyskać dodatkowe materiały szkoleniowe, zapoznaj się z kompletnymi samouczkami, przykładami kodu i dokumentacją funkcji.

Często Zadawane Pytania

Jaka jest główna funkcja IronPDF w aplikacjach ASP.NET?

IronPDF pozwala programistom na łatwe tworzenie dokumentów PDF w aplikacjach ASP.NET, usprawniając zadania takie jak generowanie faktur, raportów i innych systemów opartych na dokumentach.

Dlaczego programowe tworzenie dokumentów PDF jest ważne w nowoczesnych aplikacjach internetowych?

Programowe tworzenie dokumentów PDF jest niezbędne, ponieważ umożliwia automatyzację i dynamiczne generowanie treści dla aplikacji wymagających zarządzania dokumentami, takich jak systemy rozliczeniowe i raportowanie danych.

Czy mogę używać IronPDF do generowania plików PDF w środowiskach .NET Core?

Tak, IronPDF to potężna biblioteka .NET Core zaprojektowana specjalnie w celu uproszczenia generowania plików PDF, co czyni ją idealnym wyborem do tworzenia plików PDF w aplikacjach .NET Core.

Jakie rodzaje dokumentów mogę tworzyć za pomocą IronPDF w .NET Core?

Dzięki IronPDF możesz tworzyć szeroki zakres dokumentów, w tym faktury, raporty i wszelkie systemy oparte na dokumentach, które wymagają wydajnego generowania plików PDF.

Gdzie mogę znaleźć więcej szczegółowych informacji technicznych na temat korzystania z IronPDF?

Wszechstronne szczegóły techniczne dotyczące korzystania z IronPDF można znaleźć w oficjalnej dokumentacji, która zawiera instrukcje krok po kroku oraz praktyczne wskazówki.

W jaki sposób IronPDF rozszerza możliwości generowania plików PDF w aplikacjach ASP.NET?

IronPDF rozszerza możliwości generowania plików PDF, zapewniając solidną bibliotekę, która upraszcza tworzenie, edycję i zarządzanie dokumentami PDF bezpośrednio w aplikacjach ASP.NET.

Czy IronPDF nadaje się do tworzenia systemów opartych na dokumentach w .NET Core?

Tak, IronPDF doskonale nadaje się do tworzenia systemów opartych na dokumentach w .NET Core, ponieważ zapewnia płynny sposób programowego generowania plików PDF i zarządzania nimi.

Jakie są najlepsze metody tworzenia plików PDF w .NET Core przy użyciu IronPDF?

W samouczku omówiono różne metody tworzenia plików PDF, skupiając się na wykorzystaniu funkcji IronPDF do wydajnego generowania dokumentów PDF i zarządzania nimi w środowiskach .NET Core.

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