Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Verwendung von IronPDF
  4. Schnelle PDF-Erstellung mit ASP
IRONPDF NUTZEN

ASP PDF dynamisch erstellen: Dynamische PDF-Generierung in .NET Core

Curtis Chau
Curtis Chau
Aktualisiert:

Bei der Entwicklung moderner Webanwendungen mit ASP.NET Core ist die Möglichkeit, PDF-Dokumente dynamisch zu generieren, unerlässlich. Egal ob Rechnungen, Berichte oder Zertifikate erstellt werden, Benutzer erwarten die sofortige Generierung von PDF-Dateien ohne serverseitige Speicherung. Mit der leistungsstarken PDF-Bibliothek von IronPDF können Sie ganz einfach und direkt in Ihren .NET Core-Projekten PDFs erstellen.

In diesem Artikel zeigen wir Ihnen Schritt für Schritt, wie Sie in Ihren ASP.NET-Anwendungen ganz einfach und schnell PDF-Dokumente erstellen können.

Was bedeutet "PDFs spontan erstellen"?

Die Erstellung von PDFs in Echtzeit bedeutet, PDF-Dokumente dynamisch im Speicher zu generieren und sie direkt an den Browser des Benutzers zu streamen. Dieser serverseitige Prozess macht das Speichern von PDF-Dateien auf der Festplatte überflüssig und verbessert so sowohl die Leistung als auch die Sicherheit. Mit dem IronPDF SDK können Sie HTML-Inhalte im Handumdrehen in professionelle PDF-Dokumente umwandeln – perfekt für Webanwendungen, die PDFs erstellen müssen, ohne die Dateien auf dem Server zu speichern.

Starten Sie jetzt mit IronPDF.
green arrow pointer

Wie richtet man IronPDF für die dynamische PDF-Dateierstellung ein?

Installieren Sie zunächst IronPDF über den NuGet-Paketmanager, um diese leistungsstarke PDF-Bibliothek zu Ihrem ASP.NET Core-Projekt hinzuzufügen:

Install-Package IronPdf

Konfigurieren Sie anschließend IronPDF in Ihrer ASP.NET Core-Anwendung, um PDF-Dateien dynamisch zu erstellen:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

namespace PdfGenerator.Controllers
{
    public class DocumentController : Controller
    {
        private readonly ChromePdfRenderer _renderer;

        public DocumentController()
        {
            // Initialize the renderer once for reuse
            _renderer = new ChromePdfRenderer();
            // Optional: Set your license key
            License.LicenseKey = "YOUR-LICENSE-KEY";
        }
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

namespace PdfGenerator.Controllers
{
    public class DocumentController : Controller
    {
        private readonly ChromePdfRenderer _renderer;

        public DocumentController()
        {
            // Initialize the renderer once for reuse
            _renderer = new ChromePdfRenderer();
            // Optional: Set your license key
            License.LicenseKey = "YOUR-LICENSE-KEY";
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Diese Konfiguration initialisiert den ChromePdfRenderer , die leistungsstarke Rendering-Engine von IronPDF, die HTML-Dokumente mithilfe von Chromium in PDF-Dokumente konvertiert. Durch die Erstellung einer einzigen Renderer-Instanz optimieren Sie die Speichernutzung bei der wiederholten Erstellung von PDFs. Erfahren Sie mehr über die HTML-zu-PDF-Konvertierung und ihre fortgeschrittenen Techniken.

Wie kann man PDF-Dokumente aus HTML-Inhalten erstellen?

Die Kernfunktionalität zur Erstellung von PDF-Dateien besteht in der Umwandlung von HTML-Zeichenketten in PDF-Dokumente. Hier ist ein ausführliches Beispiel, das zeigt, wie man im Handumdrehen eine Rechnung erstellt:

[HttpGet]
public IActionResult GenerateInvoice(int orderId)
{
    // Fetch data from your database or service
    var orderData = GetOrderData(orderId);
    // Build HTML content with dynamic data
    string htmlContent = $@"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; }}
                .header {{ background-color: #f0f0f0; padding: 20px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                td, th {{ padding: 10px; border: 1px solid #ddd; }}
            </style>
        </head>
        <body>
            <div class='header'>
                <h1>Invoice #{orderData.InvoiceNumber}</h1>
                <p>Date: {DateTime.Now:yyyy-MM-dd}</p>
            </div>
            <table>
                <tr>
                    <th>Item</th>
                    <th>Quantity</th>
                    <th>Price</th>
                </tr>";
    foreach(var item in orderData.Items)
    {
        htmlContent += $@"
                <tr>
                    <td>{item.Name}</td>
                    <td>{item.Quantity}</td>
                    <td>${item.Price:F2}</td>
                </tr>";
    }
    htmlContent += @"
            </table>
        </body>
        </html>";
    // Create PDF from HTML
    var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
    // Convert to byte array for streaming
    byte[] pdfBytes = pdf.BinaryData;
    // Return PDF to browser
    return File(pdfBytes, "application/pdf", $"invoice_{orderId}.pdf");
}
[HttpGet]
public IActionResult GenerateInvoice(int orderId)
{
    // Fetch data from your database or service
    var orderData = GetOrderData(orderId);
    // Build HTML content with dynamic data
    string htmlContent = $@"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; }}
                .header {{ background-color: #f0f0f0; padding: 20px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                td, th {{ padding: 10px; border: 1px solid #ddd; }}
            </style>
        </head>
        <body>
            <div class='header'>
                <h1>Invoice #{orderData.InvoiceNumber}</h1>
                <p>Date: {DateTime.Now:yyyy-MM-dd}</p>
            </div>
            <table>
                <tr>
                    <th>Item</th>
                    <th>Quantity</th>
                    <th>Price</th>
                </tr>";
    foreach(var item in orderData.Items)
    {
        htmlContent += $@"
                <tr>
                    <td>{item.Name}</td>
                    <td>{item.Quantity}</td>
                    <td>${item.Price:F2}</td>
                </tr>";
    }
    htmlContent += @"
            </table>
        </body>
        </html>";
    // Create PDF from HTML
    var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
    // Convert to byte array for streaming
    byte[] pdfBytes = pdf.BinaryData;
    // Return PDF to browser
    return File(pdfBytes, "application/pdf", $"invoice_{orderId}.pdf");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dieser Code demonstriert, wie man dynamische PDF-Dateien generiert, indem man HTML-Seitenvorlagen mit Echtzeitdaten kombiniert. Die Methode RenderHtmlAsPdf verarbeitet den HTML-Inhalt einschließlich der CSS-Stile und erzeugt ein professionelles Dokument, das zum Download bereit ist. Die Methode unterstützt komplexe Layouts, Bilder und sogar die Ausführung von JavaScript. Sie können die Ausgabe in einem neuen Tab anzeigen.

Beispielausgabe

Dynamische PDF-Generierung mit ASP: Bild 1 – Beispiel einer dynamisch generierten PDF-Datei mit unserem ASP.NET-Programm

Wie kann man PDF-Dateien direkt an Benutzer streamen, ohne sie auf der Festplatte zu speichern?

Das Streamen von PDFs in Echtzeit erfordert die Arbeit mit Speicherströmen und Byte-Arrays. Dieser Ansatz stellt sicher, dass PDF-Dokumente niemals das Dateisystem des Servers berühren, was für Cloud-Bereitstellungen und containerisierte Anwendungen von entscheidender Bedeutung ist:

[HttpPost]
public async Task<IActionResult> CreateReport([FromBody] ReportRequest request)
{
    // Generate HTML from request data
    string html = BuildReportHtml(request);
    // Create PDF in memory
    var pdfDocument = _renderer.RenderHtmlAsPdf(html);
    // Use MemoryStream for efficient streaming
    using (var memoryStream = new MemoryStream())
    {
        // Write PDF binary data to the memory stream
        memoryStream.Write(pdfDocument.BinaryData, 0, pdfDocument.BinaryData.Length);
        // Set response headers for inline display
        Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
        // Return FileContentResult with proper content type
        return new FileContentResult(memoryStream.ToArray(), "application/pdf");
    }
}
[HttpPost]
public async Task<IActionResult> CreateReport([FromBody] ReportRequest request)
{
    // Generate HTML from request data
    string html = BuildReportHtml(request);
    // Create PDF in memory
    var pdfDocument = _renderer.RenderHtmlAsPdf(html);
    // Use MemoryStream for efficient streaming
    using (var memoryStream = new MemoryStream())
    {
        // Write PDF binary data to the memory stream
        memoryStream.Write(pdfDocument.BinaryData, 0, pdfDocument.BinaryData.Length);
        // Set response headers for inline display
        Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
        // Return FileContentResult with proper content type
        return new FileContentResult(memoryStream.ToArray(), "application/pdf");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Beispielausgabe PDF-Dokument

ASP.NET Core: Dynamische PDF-Generierung: Bild 2 – PDF erstellt mit Byte-Arrays und Streams

Der Ansatz mit Byte-Arrays ermöglicht es Ihnen, PDFs vollständig im Arbeitsspeicher zu erstellen. Der Inhaltstyp "application/pdf" teilt dem Browser mit, wie die Datei zu verarbeiten ist, während der Content-Disposition-Header festlegt, ob die PDF-Datei im Browser geöffnet oder ein Download ausgelöst wird. Weitere Details zur PDF-zu-MemoryStream-Konvertierung finden Sie in unserer Dokumentation. Wenn der Benutzer die Schaltfläche zum Senden der Anfrage drückt, führt der Server diesen Code aus, um den Vorgang fortzusetzen.

Starten Sie Ihre kostenlose Testphase und implementieren Sie noch heute die dynamische PDF-Generierung!

Wie lassen sich PDFs aus dynamischen Datenbankinhalten generieren?

In der Praxis müssen ASP.NET Core-Anwendungen häufig PDF-Berichte aus Datenbankabfragen erstellen. Hier erfahren Sie, wie Sie mit Entity Framework Core Data und korrekter Fehlerbehandlung PDFs generieren:

[HttpGet("report/monthly")]
public async Task<IActionResult> MonthlyReport(int year, int month)
{
    // Query database for report data
    var reportData = await _context.Transactions
        .Where(t => t.Date.Year == year && t.Date.Month == month)
        .GroupBy(t => t.Category)
        .Select(g => new {
            Category = g.Key,
            Total = g.Sum(t => t.Amount),
            Count = g.Count()
        })
        .ToListAsync();
    // Build HTML template with style
    var htmlTemplate = @"<h2>Monthly Report</h2>
                         <table style='width:100%'>";
    foreach(var item in reportData)
    {
        htmlTemplate += $"<tr><td>{item.Category}</td>" +
                       $"<td>{item.Count} items</td>" +
                       $"<td>${item.Total:F2}</td></tr>";
    }
    htmlTemplate += "</table>";
    // Generate PDF document with settings
    var pdf = _renderer.RenderHtmlAsPdf(htmlTemplate);
    // Add metadata to PDF
    pdf.MetaData.Title = $"Report {month}/{year}";
    pdf.MetaData.Author = "Reporting System";
    // Stream PDF to user
    return File(pdf.BinaryData, "application/pdf");
}
[HttpGet("report/monthly")]
public async Task<IActionResult> MonthlyReport(int year, int month)
{
    // Query database for report data
    var reportData = await _context.Transactions
        .Where(t => t.Date.Year == year && t.Date.Month == month)
        .GroupBy(t => t.Category)
        .Select(g => new {
            Category = g.Key,
            Total = g.Sum(t => t.Amount),
            Count = g.Count()
        })
        .ToListAsync();
    // Build HTML template with style
    var htmlTemplate = @"<h2>Monthly Report</h2>
                         <table style='width:100%'>";
    foreach(var item in reportData)
    {
        htmlTemplate += $"<tr><td>{item.Category}</td>" +
                       $"<td>{item.Count} items</td>" +
                       $"<td>${item.Total:F2}</td></tr>";
    }
    htmlTemplate += "</table>";
    // Generate PDF document with settings
    var pdf = _renderer.RenderHtmlAsPdf(htmlTemplate);
    // Add metadata to PDF
    pdf.MetaData.Title = $"Report {month}/{year}";
    pdf.MetaData.Author = "Reporting System";
    // Stream PDF to user
    return File(pdf.BinaryData, "application/pdf");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dieses Muster ermöglicht es Ihnen, PDFs aus beliebigen Datenquellen zu erstellen und Datenbankeinträge sofort in formatierte Dokumente umzuwandeln. Durch die Verwendung von HTML-Vorlagen lassen sich Berichtslayouts einfach pflegen und anpassen. Sie können auch die Erstellung von PDFs aus bestehenden Dokumenten für komplexere Szenarien erkunden und einen Link zu einem weiteren Informationsindex finden. Wir hoffen, dass dies ein gutes Beispiel ist.

Was sind die besten Vorgehensweisen für die spontane PDF-Erstellung?

Wenn Sie in ASP.NET Core dynamisch PDF-Dateien erstellen, sollten Sie folgende Optimierungsstrategien in Betracht ziehen:

Asynchrone Operationen : Verwenden Sie asynchrone Methoden, um zu verhindern, dass der Server-Threadpool blockiert wird, wenn Sie mehrere PDFs generieren:

var pdfTask = _renderer.RenderHtmlAsPdfAsync(htmlContent);
var pdf = await pdfTask;
var pdfTask = _renderer.RenderHtmlAsPdfAsync(htmlContent);
var pdf = await pdfTask;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Speicherverwaltung : Bei großen PDF-Dateien sollten Ressourcen ordnungsgemäß freigegeben und das Streaming direkt zur Antwort in Betracht gezogen werden, um den Speicherverbrauch zu minimieren:

using (var pdf = _renderer.RenderHtmlAsPdf(html))
{
    return File(pdf.Stream, "application/pdf");
}
using (var pdf = _renderer.RenderHtmlAsPdf(html))
{
    return File(pdf.Stream, "application/pdf");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Renderer-Wiederverwendung : Um die Leistung beim Generieren mehrerer PDFs zu verbessern, können ChromePdfRenderer-Instanzen anfragenübergreifend geteilt werden. Der Renderer ist threadsicher und kann parallele Operationen effizient verarbeiten. Es stimmt auch, dass die Wiederverwendung des Renderers Zeit spart. Lassen Sie sich diese Optimierung nicht entgehen.

Gemäß den Best Practices von Microsoft für ASP.NET Core sind die Minimierung von Objektzuweisungen und die Wiederverwendung von Ressourcen der Schlüssel zu leistungsstarken Webanwendungen.

NuGet Mit NuGet installieren

PM >  Install-Package IronPdf

Schauen Sie sich IronPDF auf NuGet für eine schnelle Installation an. Mit über 10 Millionen Downloads transformiert es die PDF-Entwicklung mit C#. Sie können auch das DLL oder den Windows Installer herunterladen.

Abschluss

Mit IronPDF lassen sich PDF-Dokumente im Handumdrehen erstellen, wodurch die komplexe Dokumentengenerierung in unkomplizierten Code umgewandelt wird. Von einfachen Rechnungen bis hin zu komplexen Berichten – das leistungsstarke SDK von IronPDF übernimmt die schwere Arbeit, während Sie sich auf Ihre Anwendungslogik konzentrieren. Die Möglichkeit, PDFs zu generieren und zu streamen, ohne sie auf der Festplatte zu speichern, macht Ihre ASP.NET Core-Anwendungen effizienter und sicherer. Wir integrieren ständig neue Funktionen und Sie können sich von all unseren Beispielen inspirieren lassen. Dies ist ein offizielles Dokument für die Bibliothek.

Mit IronPDF können Sie PDFs aus HTML-Inhalten erstellen, diese als Byte-Arrays streamen und professionelle Dokumente sofort an die Benutzer ausliefern. Egal ob Sie ein Berichtssystem, einen Rechnungsgenerator oder eine Dokumentenmanagementlösung entwickeln, IronPDF bietet Ihnen alle Funktionen, die Sie für eine zuverlässige PDF-Erstellung benötigen. Sie können auch eine neue Nachricht verfassen, um Unterstützung zu erhalten. Der Text ist eindeutig.

Sind Sie bereit, Ihre ASP.NET Core-Anwendung mit dynamischen PDF-Funktionen auszustatten? Erwerben Sie eine Lizenz , um alle Funktionen freizuschalten und professionellen Support von unserem Ingenieurteam zu erhalten.

Häufig gestellte Fragen

Wie kann ich in ASP.NET Core dynamisch PDFs generieren?

Mit IronPDF können Sie in ASP.NET Core dynamisch PDFs generieren, ohne die Dateien auf der Festplatte zu speichern. So können Sie PDFs direkt an Browser streamen.

Welche Vorteile bietet IronPDF für die PDF-Erstellung?

IronPDF bietet eine leistungsstarke Rendering-Engine, die die dynamische PDF-Erstellung direkt in Ihren .NET Core-Projekten ermöglicht und so eine sofortige PDF-Generierung ohne serverseitigen Speicherbedarf gewährleistet.

Kann IronPDF zur Erstellung von Rechnungen und Berichten verwendet werden?

Ja, IronPDF eignet sich zur Erstellung verschiedener Dokumenttypen wie Rechnungen, Berichte und Zertifikate, die alle in ASP.NET Core-Anwendungen dynamisch generiert werden.

Ist serverseitiger Speicher bei der Verwendung von IronPDF erforderlich?

Nein, IronPDF ermöglicht es Ihnen, PDFs direkt an Browser zu generieren und zu streamen, ohne dass serverseitiger Speicher benötigt wird. Dadurch ist es effizient und schnell.

Welche Anwendungen können von der dynamischen PDF-Generierung profitieren?

Moderne Webanwendungen, insbesondere solche, die eine Echtzeit-Dokumenterstellung erfordern, wie z. B. Rechnungssysteme und Reporting-Tools, können von der von IronPDF bereitgestellten PDF-Generierung in Echtzeit stark profitieren.

Unterstützt IronPDF for .NET Core-Projekte?

Ja, IronPDF ist vollständig kompatibel mit .NET Core-Projekten, sodass Entwickler PDF-Generierungsfunktionen nahtlos in ihre Anwendungen integrieren können.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen