Wie man dynamisch PDFs in C# generiert

Wie funktioniert serverseitiges PDF-Rendering in ASP.NET?

IronPDF verschiebt die PDF-Darstellung vollständig auf den Server mithilfe einer Headless Chrome-Engine. Ihr Controller generiert oder ruft ein PDF-Dokument ab, konvertiert es in ein Byte-Array und streamt es mit einem inline Content-Disposition-Header zum Browser. Der eingebaute PDF-Viewer des Browsers zeigt dann das Dokument in einem <iframe>, eingebettet in Ihr Panel, an.

Dieser grundlegende Shift beseitigt die traditionellen Schwachstellen:

Auf dem Client-Rechner ist kein Adobe Reader oder eine Browsererweiterung erforderlich.

• Einheitliche Darstellung unabhängig vom Betriebssystem oder der Browserversion des Benutzers.
• Vollständige programmatische Kontrolle über Dokumentinhalt, Layout und Styling
• Funktioniert in Enterprise , in denen IT-Richtlinien die Installation von Plugins blockieren.

Die Chrome-Rendering-Engine der Bibliothek erzeugt pixelgenaue Ausgaben aus HTML-, URL- und Rohinhaltsquellen. Sie haben die volle Kontrolle über jeden Aspekt der Ausgabe – Papierformat, Ränder, Kopf- und Fußzeilen sowie CSS-Medientyp –, bevor die PDF-Datei überhaupt den Kunden erreicht.

IronPDF unterstützt außerdem die plattformübergreifende Bereitstellung auf Windows-, Linux- und macOS-Servern und eignet sich daher sowohl für cloudbasierte ASP.NET Anwendungen, die auf Azure oder AWS laufen, als auch für containerisierte Umgebungen mit Docker .

Wie richtet man das NuGet Paket ein?

Öffnen Sie Visual Studio, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt und wählen Sie "NuGet Pakete verwalten" . Suchen Sie nach IronPdf und installieren Sie es. Alternativ können Sie diesen Befehl in der Paket-Manager-Konsole ausführen:

Install-Package IronPdf

Sie können auch die .NET CLI mit dotnet add package IronPdf verwenden. Sobald installiert, fügen Sie using IronPdf; oben in Ihrer Controller- oder Dienstklasse hinzu, um Zugriff auf den Namensraum der Bibliothek zu haben.

Für eine optimale PDF-Bereitstellung konfigurieren Sie Ihre Program.cs, um statische Dateien zu servieren und Routing einzurichten:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseStaticFiles();
app.UseRouting();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseStaticFiles();
app.UseRouting();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection

Dim builder = WebApplication.CreateBuilder(args)

builder.Services.AddControllersWithViews()
builder.Services.AddRazorPages()

Dim app = builder.Build()

app.UseStaticFiles()
app.UseRouting()

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}")

app.Run()

Die AddControllersWithViews()-Registrierung ermöglicht sowohl API-Endpunkte als auch die Darstellung von Ansichten - beides ist erforderlich, wenn Sie PDF-Inhalte über dedizierte Controlleraktionen bereitstellen und sie in Razor-Ansichtspanels anzeigen wollen. Für detaillierte Konfigurationsinformationen konsultieren Sie die IronPDF -API-Dokumentation .

Wie kann man eine PDF-Datei direkt in einem Panel anzeigen?

Das grundlegende Muster ist einfach: Eine Controlleraktion erzeugt ein PDF, konvertiert es in Bytes, setzt den Content-Disposition-Header auf inline und gibt ein File-Ergebnis zurück. Ein <iframe> in der Razor-Ansicht zeigt auf diesen Endpunkt.

Hier ist eine vollständige Controller-Implementierung:

[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
    [HttpGet("display/{documentId}")]
    public IActionResult DisplayPdfInPanel(string documentId)
    {
        var renderer = new ChromePdfRenderer();

        string filename = $"document_{documentId}.pdf";

        var htmlContent = $@"
            <html>
            <head>
                <style>
                    body {{font-family: Arial, sans-serif; margin: 40px;}}
                    h1 {{color: #333;}}
                    .content {{line-height: 1.6;}}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This PDF is generated dynamically and displayed inline in your panel.</p>
                    <p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>";

        using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        byte[] pdfBytes = pdfDocument.BinaryData;

        Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");

        return File(pdfBytes, "application/pdf");
    }
}

[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
    [HttpGet("display/{documentId}")]
    public IActionResult DisplayPdfInPanel(string documentId)
    {
        var renderer = new ChromePdfRenderer();

        string filename = $"document_{documentId}.pdf";

        var htmlContent = $@"
            <html>
            <head>
                <style>
                    body {{font-family: Arial, sans-serif; margin: 40px;}}
                    h1 {{color: #333;}}
                    .content {{line-height: 1.6;}}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This PDF is generated dynamically and displayed inline in your panel.</p>
                    <p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>";

        using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        byte[] pdfBytes = pdfDocument.BinaryData;

        Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");

        return File(pdfBytes, "application/pdf");
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports System

<ApiController>
<Route("api/[controller]")>
Public Class PdfPanelController
    Inherits ControllerBase

    <HttpGet("display/{documentId}")>
    Public Function DisplayPdfInPanel(documentId As String) As IActionResult
        Dim renderer = New ChromePdfRenderer()

        Dim filename As String = $"document_{documentId}.pdf"

        Dim htmlContent As String = $"
            <html>
            <head>
                <style>
                    body {{font-family: Arial, sans-serif; margin: 40px;}}
                    h1 {{color: #333;}}
                    .content {{line-height: 1.6;}}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This PDF is generated dynamically and displayed inline in your panel.</p>
                    <p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>"

        Using pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
            Dim pdfBytes As Byte() = pdfDocument.BinaryData

            Response.Headers.Append("Content-Disposition", $"inline; filename={filename}")

            Return File(pdfBytes, "application/pdf")
        End Using
    End Function
End Class

Die ChromePdfRenderer-Klasse ist der primäre Einstiegspunkt für serverseitige Darstellung. Es akzeptiert HTML-Inhalte, konvertiert sie mithilfe eines Headless-Browsers und gibt ein PdfDocument-Objekt zurück. Die BinaryData-Eigenschaft zeigt die rohen Bytes zum Streaming an.

Das Setzen von Content-Disposition auf inline ist der entscheidende Schritt für die Panelanzeige. Ohne diese Eingabeaufforderung würde der Browser einen Download einleiten, anstatt direkt in der <iframe>-Ansicht zu rendern. Sie können auch Kopfzeilen und Fußzeilen hinzufügen und Seitenorientierung und kundenspezifische Ränder über RenderingOptions steuern.

Um diesen Endpunkt in einem Razor-Panel einzubetten, erstellen Sie ein <iframe>, das auf die Controller-Route zeigt:

@page
@model IndexModel

<div class="container mt-4">
    <div class="card">
        <div class="card-header">
            <h3>PDF Display Panel</h3>
        </div>
        <div class="card-body">
            <div class="pdf-panel" style="height: 600px;">
                <iframe src="/api/PdfPanel/display/12345"
                        width="100%"
                        height="100%"
                        frameborder="0">
                </iframe>
            </div>
        </div>
    </div>
</div>

@page
@model IndexModel

<div class="container mt-4">
    <div class="card">
        <div class="card-header">
            <h3>PDF Display Panel</h3>
        </div>
        <div class="card-body">
            <div class="pdf-panel" style="height: 600px;">
                <iframe src="/api/PdfPanel/display/12345"
                        width="100%"
                        height="100%"
                        frameborder="0">
                </iframe>
            </div>
        </div>
    </div>
</div>

The provided code is a Razor page markup, which is not directly translatable to VB.NET as it is not C# code. Razor pages are used in ASP.NET Core for creating dynamic web pages and are written in a combination of HTML and C#.

If you need to convert the C# logic within a Razor page to VB.NET, you would typically focus on the code-behind file or any C# code embedded within the Razor markup. However, the provided snippet contains only HTML and Razor directives without any C# logic to convert.

If you have a specific C# code-behind logic or embedded C# code within a Razor page that you need to convert to VB.NET, please provide that portion, and I can assist with the conversion.

Der <iframe> fordert das PDF von Ihrem Controller-Endpunkt an. Der im Browser integrierte PDF-Viewer übernimmt von da an und zeigt das Dokument in voller Breite und Höhe des Bedienfelds an, ohne dass clientseitige Bibliotheken oder Plugins benötigt werden.

Wie lädt man PDFs dynamisch mit AJAX?

Statische <iframe>-Quellen funktionieren gut für festen Inhalt, aber viele Anwendungen müssen PDFs basierend auf Benutzeraktionen laden - durch Klicken auf einen Datensatz in einem Datenraster, Absenden eines Formulars oder Auswahl eines Berichtstyps. Ein AJAX-basierter Ansatz bewältigt diese Szenarien ohne vollständiges Neuladen der Seite.

Die Controller-Aktion akzeptiert einen Anfragetext und gibt das PDF als Base64-String zurück:

[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
    try
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;

        var htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<html><body>");
        htmlBuilder.Append($"<h2>{request.Title}</h2>");
        htmlBuilder.Append($"<div>{request.Content}</div>");

        if (request.IncludeData)
        {
            htmlBuilder.Append("<table border='1' style='width:100%;'>");
            foreach (var item in request.DataItems)
            {
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>");
            }
            htmlBuilder.Append("</table>");
        }

        htmlBuilder.Append("</body></html>");

        var pdfDocument = await Task.Run(() =>
            renderer.RenderHtmlAsPdf(htmlBuilder.ToString()));

        var base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData);

        return Ok(new { success = true, pdfData = base64Pdf });
    }
    catch (Exception ex)
    {
        return BadRequest(new { success = false, error = ex.Message });
    }
}

[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
    try
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;

        var htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<html><body>");
        htmlBuilder.Append($"<h2>{request.Title}</h2>");
        htmlBuilder.Append($"<div>{request.Content}</div>");

        if (request.IncludeData)
        {
            htmlBuilder.Append("<table border='1' style='width:100%;'>");
            foreach (var item in request.DataItems)
            {
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>");
            }
            htmlBuilder.Append("</table>");
        }

        htmlBuilder.Append("</body></html>");

        var pdfDocument = await Task.Run(() =>
            renderer.RenderHtmlAsPdf(htmlBuilder.ToString()));

        var base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData);

        return Ok(new { success = true, pdfData = base64Pdf });
    }
    catch (Exception ex)
    {
        return BadRequest(new { success = false, error = ex.Message });
    }
}

Imports System.Text
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

<HttpPost("generate")>
Public Async Function GenerateDynamicPdf(<FromBody> request As PdfRequestModel) As Task(Of IActionResult)
    Try
        Dim renderer = New ChromePdfRenderer()

        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        renderer.RenderingOptions.MarginLeft = 20
        renderer.RenderingOptions.MarginRight = 20

        Dim htmlBuilder = New StringBuilder()
        htmlBuilder.Append("<html><body>")
        htmlBuilder.Append($"<h2>{request.Title}</h2>")
        htmlBuilder.Append($"<div>{request.Content}</div>")

        If request.IncludeData Then
            htmlBuilder.Append("<table border='1' style='width:100%;'>")
            For Each item In request.DataItems
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>")
            Next
            htmlBuilder.Append("</table>")
        End If

        htmlBuilder.Append("</body></html>")

        Dim pdfDocument = Await Task.Run(Function() renderer.RenderHtmlAsPdf(htmlBuilder.ToString()))

        Dim base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData)

        Return Ok(New With {Key .success = True, Key .pdfData = base64Pdf})
    Catch ex As Exception
        Return BadRequest(New With {Key .success = False, Key .error = ex.Message})
    End Try
End Function

Der RenderingOptions-Block lässt Sie Papiergröße, Ränder und CSS-Mediatyp vor dem Rendern konfigurieren. Laut der ASP.NET Core -Dokumentation von Microsoft sind asynchrone Muster unerlässlich, um auch unter Last reaktionsfähige Benutzeroberflächen zu gewährleisten. Das umschließende synchronisierte Rendern in Task.Run hält den Anforderungs-Thread frei, während die Chrome-Engine das HTML verarbeitet.

Die Base64-Antwort ermöglicht es dem JavaScript-Client, die <iframe>-Quelle direkt zu aktualisieren, ohne einen Seitenneulader durchzuführen:

fetch('/api/PdfPanel/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(requestData)
})
.then(response => response.json())
.then(result => {
    if (result.success) {
        const iframe = document.getElementById('pdf-frame');
        iframe.src = 'data:application/pdf;base64,' + result.pdfData;
    }
});

fetch('/api/PdfPanel/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(requestData)
})
.then(response => response.json())
.then(result => {
    if (result.success) {
        const iframe = document.getElementById('pdf-frame');
        iframe.src = 'data:application/pdf;base64,' + result.pdfData;
    }
});

Dieses Muster funktioniert gut für Razor-Seiten und MVC-Ansichten gleichermaßen. Für fortgeschrittene Anwendungsfälle unterstützt IronPDF auch asynchrone Darstellung nativ, sodass Sie RenderHtmlAsPdfAsync direkt anstelle von Task.Run verwenden können.

Wie gehen Sie mit verschiedenen PDF-Quelltypen um?

IronPDF kann PDFs aus drei primären Quellen generieren: HTML-Zeichenketten, lokalen HTML-Dateien und externen URLs. Jedes eignet sich für unterschiedliche Szenarien.

[HttpGet("from-html")]
public IActionResult GenerateFromHtmlString(string reportType)
{
    var renderer = new ChromePdfRenderer();

    var htmlTemplate = GetHtmlTemplate(reportType);

    var userName = User?.Identity?.Name ?? "Unknown";

    var processedHtml = htmlTemplate
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", userName)
        .Replace("{{REPORT_TYPE}}", reportType);

    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"));

    return File(pdf.BinaryData, "application/pdf");
}

private string GetHtmlTemplate(string reportType)
{
    return @"
        <html>
        <head><title>{{REPORT_TYPE}} Report</title></head>
        <body>
            <h1>{{REPORT_TYPE}} Report</h1>
            <p>Date: {{DATE}}</p>
            <p>User: {{USER}}</p>
            <div>Report content goes here.</div>
        </body>
        </html>";
}

[HttpGet("from-html")]
public IActionResult GenerateFromHtmlString(string reportType)
{
    var renderer = new ChromePdfRenderer();

    var htmlTemplate = GetHtmlTemplate(reportType);

    var userName = User?.Identity?.Name ?? "Unknown";

    var processedHtml = htmlTemplate
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", userName)
        .Replace("{{REPORT_TYPE}}", reportType);

    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"));

    return File(pdf.BinaryData, "application/pdf");
}

private string GetHtmlTemplate(string reportType)
{
    return @"
        <html>
        <head><title>{{REPORT_TYPE}} Report</title></head>
        <body>
            <h1>{{REPORT_TYPE}} Report</h1>
            <p>Date: {{DATE}}</p>
            <p>User: {{USER}}</p>
            <div>Report content goes here.</div>
        </body>
        </html>";
}

Imports System
Imports Microsoft.AspNetCore.Mvc
Imports IronPdf
Imports System.IO

<HttpGet("from-html")>
Public Function GenerateFromHtmlString(reportType As String) As IActionResult
    Dim renderer As New ChromePdfRenderer()

    Dim htmlTemplate As String = GetHtmlTemplate(reportType)

    Dim userName As String = If(User?.Identity?.Name, "Unknown")

    Dim processedHtml As String = htmlTemplate _
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
        .Replace("{{USER}}", userName) _
        .Replace("{{REPORT_TYPE}}", reportType)

    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

    Using pdf = renderer.RenderHtmlAsPdf(processedHtml)
        pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"))
        Return File(pdf.BinaryData, "application/pdf")
    End Using
End Function

Private Function GetHtmlTemplate(reportType As String) As String
    Return "
        <html>
        <head><title>{{REPORT_TYPE}} Report</title></head>
        <body>
            <h1>{{REPORT_TYPE}} Report</h1>
            <p>Date: {{DATE}}</p>
            <p>User: {{USER}}</p>
            <div>Report content goes here.</div>
        </body>
        </html>"
End Function

[HttpGet("from-url")]
public async Task<IActionResult> GenerateFromUrl(string encodedUrl)
{
    var url = HttpUtility.UrlDecode(encodedUrl);

    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.ViewPortWidth = 1920;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay(2000);

    using var pdf = await renderer.RenderUrlAsPdfAsync(url);

    Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");

    return File(pdf.BinaryData, "application/pdf");
}

[HttpGet("from-url")]
public async Task<IActionResult> GenerateFromUrl(string encodedUrl)
{
    var url = HttpUtility.UrlDecode(encodedUrl);

    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.ViewPortWidth = 1920;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay(2000);

    using var pdf = await renderer.RenderUrlAsPdfAsync(url);

    Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");

    return File(pdf.BinaryData, "application/pdf");
}

Imports System.Web
Imports Microsoft.AspNetCore.Mvc

<HttpGet("from-url")>
Public Async Function GenerateFromUrl(encodedUrl As String) As Task(Of IActionResult)
    Dim url = HttpUtility.UrlDecode(encodedUrl)

    Dim renderer = New ChromePdfRenderer()

    renderer.RenderingOptions.ViewPortWidth = 1920
    renderer.RenderingOptions.EnableJavaScript = True
    renderer.RenderingOptions.WaitFor.RenderDelay(2000)

    Using pdf = Await renderer.RenderUrlAsPdfAsync(url)
        Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf")
        Return File(pdf.BinaryData, "application/pdf")
    End Using
End Function

Wie verwalten Sie Speicher und Leistung?

Die PDF-Erzeugung ist ressourcenintensiv. Jeder Aufruf von ChromePdfRenderer erstellt einen Headless-Chrome-Prozess, und jedes PdfDocument-Objekt hält die gerenderten Bytes im Speicher. Durch eine ordnungsgemäße Speicherbereinigung werden Ressourcenlecks vermieden und der Speicherverbrauch unter Last vorhersehbar gehalten.

Verwenden Sie immer using-Anweisungen mit PdfDocument:

public IActionResult OptimizedPdfGeneration()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;

    var processedHtml = GetHtmlTemplate("report")
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", "Test")
        .Replace("{{REPORT_TYPE}}", "Report");

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    byte[] pdfBytes = pdf.BinaryData;
    pdf.SaveAs("output.pdf");

    return File(pdfBytes, "application/pdf");
}

public IActionResult OptimizedPdfGeneration()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;

    var processedHtml = GetHtmlTemplate("report")
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", "Test")
        .Replace("{{REPORT_TYPE}}", "Report");

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    byte[] pdfBytes = pdf.BinaryData;
    pdf.SaveAs("output.pdf");

    return File(pdfBytes, "application/pdf");
}

Imports System
Imports Microsoft.AspNetCore.Mvc

Public Class PdfController
    Inherits Controller

    Public Function OptimizedPdfGeneration() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.CreatePdfFormsFromHtml = False

        Dim processedHtml = GetHtmlTemplate("report") _
            .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
            .Replace("{{USER}}", "Test") _
            .Replace("{{REPORT_TYPE}}", "Report")

        Using pdf = renderer.RenderHtmlAsPdf(processedHtml)
            Dim pdfBytes As Byte() = pdf.BinaryData
            pdf.SaveAs("output.pdf")

            Return File(pdfBytes, "application/pdf")
        End Using
    End Function

    Private Function GetHtmlTemplate(templateName As String) As String
        ' Placeholder for the actual implementation
        Return String.Empty
    End Function
End Class

Die using-Anweisung stellt sicher, dass das PdfDocument-Objekt sofort nach der Extraktion des Byte-Arrays freigegeben wird, selbst wenn weiter unten eine Ausnahme auftritt. Für Anwendungen, die häufig PDFs erzeugen, sollten Sie folgende zusätzliche Strategien in Betracht ziehen:

• Zwischenspeicherung : Häufig angeforderte PDFs werden im Arbeitsspeicher oder auf der Festplatte gespeichert. Verwenden Sie IMemoryCache zur Zwischenspeicherung des Byte-Arrays, das nach einem Dokumentenidentifikator und Zeitstempel geordnet ist.
• Streaming : Bei sehr großen Dokumenten sollten PDF-Speicherströme anstelle von Byte-Arrays verwendet werden, um die Zuweisung großer zusammenhängender Speicherblöcke zu vermeiden.
• Linearisierung : Aktivieren Sie die linearisierte (schnelle Webansicht) Ausgabe , damit Browser mit dem Rendern beginnen können, bevor die vollständige Datei heruntergeladen ist.
• Komprimierung : Wenden Sie die PDF-Komprimierung an, um die Dateigröße zu reduzieren, wenn Dokumente über eingeschränkte Netzwerkverbindungen bereitgestellt werden.

Der IronPDF Leistungsleitfaden enthält zusätzliche Optimierungsstrategien für Szenarien mit hohem Durchsatz.

Wie gewährleisten Sie Sicherheit und Browserkompatibilität?

Sicherheit und Zuverlässigkeit verdienen gleichermaßen Beachtung, bevor Sie PDF-Panel-Displays in der Produktion einsetzen.

Eingabevalidierung : Dynamische Inhalte müssen vor dem Einfügen in HTML-Vorlagen immer bereinigt werden. Ungeprüfte Benutzereingaben, die über die Chrome-Engine gerendert werden, können Ihren Server SSRF- und XSS-Angriffen aussetzen. Verwenden Sie etablierte HTML-Codierungsbibliotheken oder beschränken Sie die zulässigen Zeichen auf eine sichere Zulassungsliste.

Zugriffskontrolle : Schützen Sie Ihre PDF-Endpunkte mit Authentifizierungs- und Autorisierungs-Middleware . Eine URL wie /api/PdfPanel/display/12345, die ein Dokument zurückgibt, ohne die Identität des Anrufers zu überprüfen, stellt ein Risiko für die Datenexponierung dar. Wenden Sie [Authorize]-Attribute an und validieren Sie, dass der authentifizierte Benutzer die Berechtigung hat, auf die angeforderte Dokument-ID zuzugreifen.

MIME-Typ-Konfiguration: Geben Sie immer application/pdf als Inhaltstyp zurück. Browser, die einen falschen MIME-Typ erhalten, können einen Download-Dialog auslösen oder die Inline-Darstellung ablehnen. Stellen Sie sicher, dass die MIME-Typ-Zuordnungen Ihrer Anwendung PDF enthalten, wenn Sie auch statische PDF-Dateien von wwwroot bereitstellen.

Browserübergreifende Inline-Anzeige: Moderne Browser - Chrome, Firefox, Edge und Safari - unterstützen alle die Inline-PDF-Anzeige über den Content-Disposition: inline-Header. Die W3C-Spezifikation für Content Security Policy bietet Hinweise zu Frame-Ancestors-Direktiven, falls Ihre Panels PDFs aus verschiedenen Quellen einbetten. IronPDFs serverseitiges Rendering beseitigt die meisten Inkonsistenzen bei der Browserdarstellung, da die PDF-Generierung unabhängig vom Client erfolgt.

Fehlerbehandlung : Die PDF-Generierung sollte in try-catch-Blöcke eingeschlossen werden, um aussagekräftige HTTP-Statuscodes zurückzugeben. Eine 500er-Antwort ohne Körperkontakt ist schwer zu diagnostizieren. Geben Sie ein strukturiertes Fehlerobjekt zurück, damit der clientseitige Code eine benutzerfreundliche Nachricht anstelle eines kaputten <iframe> anzeigen kann.

Für die Dokumentensicherheit unterstützt IronPDF Passwortschutz und Berechtigungen , digitale Signaturen und PDF/A-Konformität für Archivierungsanforderungen.

Was sind Ihre nächsten Schritte?

Sie haben nun ein funktionierendes Muster für die Anzeige von PDFs in ASP.NET-Panels: Installieren Sie IronPDF, erstellen Sie eine Controller-Aktion, die ein PDF erzeugt und es mit Content-Disposition: inline zurückgibt, und betten Sie den Endpunkt in ein <iframe> in Ihrem Razor-Panel ein. Mit dem AJAX-Muster können Sie Dokumente dynamisch als Reaktion auf Benutzeraktionen laden, ohne dass die Seite neu geladen werden muss.

Starten Sie eine kostenlose Testversion von IronPDF , um diese Muster in Ihrem eigenen Projekt auszuprobieren – keine Kreditkarte erforderlich. Die Testversion beinhaltet den vollen Zugriff auf alle Funktionen, einschließlich HTML-zu-PDF-Konvertierung, URL-Erfassung und erweiterter PDF-Bearbeitung.

Sobald die grundlegende Anzeige funktioniert, sollten Sie diese naheliegenden Erweiterungen in Betracht ziehen:

• PDF-Dateien für Dokumentenerstellungs-Workflows zusammenführen oder aufteilen
• Erstellen Sie ausfüllbare PDF-Formulare aus HTML-Formularen
• Digitale Signaturen zur Dokumentenauthentifizierung hinzufügen
• Bearbeiten Sie vorhandene PDFs, um Inhalte zu stempeln, zu kommentieren oder zu schwärzen.
• HTML in PDF konvertieren mit vollständiger CSS- und JavaScript Unterstützung für komplexe Berichtslayouts

Die IronPDF Dokumentation behandelt jede dieser Funktionen ausführlich, mit vollständigen Codebeispielen und Konfigurationsreferenzen.