PDF-Anzeige im ASP.NET-Panel mit IronPDF

Wie funktioniert serverseitiges PDF-Rendering in ASP.NET?

IronPDF verlagert das PDF-Rendering vollständig auf den Server und nutzt dafür eine Headless-Chrome-Engine. Ihr Controller generiert oder ruft ein PDF-Dokument ab, konvertiert es in ein Byte-Array und streamt es mit einem Content-Disposition-Header an den Browser. Der im Browser integrierte PDF-Viewer zeigt das Dokument dann in einem <iframe> an, das in Ihr Panel eingebettet ist.

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. Nach der Installation fügen Sie using IronPdf; am Anfang Ihrer Controller- oder Serviceklasse ein, um auf den Namespace der Bibliothek zuzugreifen.

Für eine optimale PDF-Zustellung konfigurieren Sie Ihren Program.cs so, dass er statische Dateien ausliefert, und richten Sie das Routing ein:

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 Registrierung AddControllersWithViews() ermöglicht sowohl API-Endpunkte als auch das Rendern von Ansichten – beides ist erforderlich, wenn Sie PDF-Inhalte über spezielle Controller-Aktionen bereitstellen und in Razor -Ansichtspanels anzeigen möchten. Für detaillierte Konfigurationsinformationen konsultieren Sie die IronPDF -API-Dokumentation .

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

Das Grundmuster ist einfach: Eine Controller-Aktion generiert ein PDF, konvertiert es in Bytes, setzt den Header Content-Disposition auf inline und gibt ein Ergebnis vom Typ File zurück. Ein <iframe> in der Razor Ansicht verweist 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 Klasse ChromePdfRenderer ist der primäre Einstiegspunkt für das serverseitige Rendering. Es akzeptiert HTML-Inhalte, konvertiert sie mithilfe eines Headless-Chrome-Browsers und gibt ein PdfDocument-Objekt zurück. Die Eigenschaft BinaryData stellt die Rohbytes für das Streaming bereit.

Die Einstellung von Content-Disposition auf inline ist der entscheidende Schritt für die Anzeige auf dem Bedienfeld. Ohne diese Einstellung fordert der Browser einen Download an, anstatt die Inhalte innerhalb von <iframe> darzustellen. Sie können außerdem Kopf- und Fußzeilen zu jeder Seite hinzufügen oder die Seitenausrichtung und benutzerdefinierte Ränder über RenderingOptions steuern.

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

@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 eignen sich gut für feste Inhalte, aber viele Anwendungen müssen PDFs basierend auf Benutzeraktionen laden – z. B. durch Klicken auf einen Datensatz in einem Datenraster, Absenden eines Formulars oder Auswählen 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

Mit dem RenderingOptions Block können Sie Papierformat, Ränder und CSS-Medientyp 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. Durch das Einbetten des synchronen Renderaufrufs in Task.Run bleibt der Anfragethread frei, während die Chrome-Engine das HTML verarbeitet.

Die Base64-Antwort ermöglicht es dem JavaScript Client, den Quellcode <iframe> direkt zu aktualisieren, ohne dass die Seite neu geladen werden muss:

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 eignet sich sowohl für Razor Pages als auch für MVC-Ansichten. Für fortgeschrittene Anwendungsfälle unterstützt IronPDF zudem nativ asynchrones Rendering , 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-Generierung ist ressourcenintensiv. Jeder Aufruf von ChromePdfRenderer erzeugt einen Headless-Chrome-Prozess, und jedes PdfDocument-Objekt speichert die gerenderten Bytes im Speicher. Durch eine ordnungsgemäße Speicherbereinigung werden Ressourcenlecks vermieden und der Speicherverbrauch unter Last vorhersehbar gehalten.

Verwenden Sie using Anweisungen immer zusammen 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 Anweisung using stellt sicher, dass das Objekt PdfDocument sofort nach dem Extrahieren des Byte-Arrays freigegeben wird, selbst wenn später 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, um das Byte-Array, das durch eine Dokumentkennung und einen Zeitstempel indiziert ist, zwischenzuspeichern.
• 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 Aufrufers zu überprüfen, stellt ein Risiko für die Offenlegung von Daten dar. Wenden Sie die Attribute [Authorize] an und überprüfen Sie, ob der authentifizierte Benutzer die Berechtigung hat, auf die angeforderte Dokument-ID zuzugreifen.

MIME-Typ-Konfiguration : Immer application/pdf als Inhaltstyp zurückgeben. Browser, die einen falschen MIME-Typ empfangen, können einen Download-Dialog auslösen oder die Inline-Darstellung verweigern. Überprüfen Sie, ob 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. Gibt ein strukturiertes Fehlerobjekt zurück, damit clientseitiger Code eine benutzerfreundliche Meldung anstelle des fehlerhaften <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 zum Anzeigen von PDFs in ASP.NET Panels: Installieren Sie IronPDF, erstellen Sie eine Controller-Aktion, die ein PDF generiert und es mit Content-Disposition: inline zurückgibt, und betten Sie den Endpunkt in ein <iframe> innerhalb Ihres Razor Panels 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.