ASP.NET Anzeige von PDF im Panel mit IronPDF

Wie vereinfacht IronPDF die Anzeige von PDF-Dateien in Panels?

IronPDF revolutioniert die PDF-Verarbeitung in ASP.NET Core, indem der Rendering-Prozess vollständig auf den Server verlagert wird. Dieser grundlegende Ansatz beseitigt die üblichen Probleme der clientseitigen PDF-Anzeige und ermöglicht Ihnen gleichzeitig die effektive, programmatische Steuerung der Dokumentgenerierung und -präsentation durch die Chrome-Rendering-Engine .

Die serverseitige Rendering-Engine der Bibliothek sorgt dafür, dass Ihre PDFs unabhängig vom Browser, Betriebssystem oder den installierten Plugins des Benutzers konsistent angezeigt werden. Benutzer benötigen weder Adobe Reader noch Browsererweiterungen oder sonstige Drittanbietersoftware, um PDFs innerhalb Ihrer Anwendung anzuzeigen . Diese Universalität erweist sich insbesondere in Unternehmensumgebungen als wertvoll, in denen IT-Richtlinien die Installation von Plugins einschränken können. Der Chrome PDF Renderer gewährleistet pixelgenaue Präzision bei der Konvertierung von HTML in PDF.

Die Architektur von IronPDF bietet auch erhebliche Vorteile für moderne Einsatzszenarien. Die Bibliothek bietet zuverlässige plattformübergreifende Unterstützung und läuft reibungslos auf Windows- , Linux- und macOS -Servern. Die Bereitstellung in Containern wird vollständig unterstützt, wodurch IronPDF ideal für Anwendungen geeignet ist, die in Docker-Containern oder Kubernetes-Clustern laufen. Diese Flexibilität gewährleistet, dass Ihre PDF-Anzeigefunktionen in Entwicklungs-, Test- und Produktionsumgebungen auf Azure oder AWS konsistent funktionieren.

IronPDF bietet eine Übersicht der Funktionen in vier Hauptkategorien: PDFs erstellen, PDFs konvertieren, PDFs bearbeiten sowie PDFs signieren und sichern. Jede Kategorie enthält eine detaillierte Funktionsliste.

Wie richtet man IronPDF für die Anzeige am Bildschirm ein?

Für den Einsatz von IronPDF in Ihrem ASP.NET Core-Projekt sind nur ein paar einfache Schritte erforderlich. Öffnen Sie zunächst Visual Studio und gehen Sie zum Projektmappen-Explorer. Klicken Sie mit der rechten Maustaste auf Ihr Projekt und wählen Sie "NuGet-Paket-Manager verwalten", um das IronPDF NuGet-Paket zu installieren. Sie können den folgenden Code auch in Ihrer Paketmanager-Konsole ausführen:

Install-Package IronPdf

Die Paket-Manager-Konsole zeigt den Installationsprozess des IronPdf-NuGet-Pakets mit mehreren heruntergeladenen Abhängigkeiten an.

Alternativ können Sie für Ihre .NET Framework- oder .NET Core-Anwendungen die .NET CLI verwenden, um das Paket herunterzuladen:

dotnet add package IronPdf

Nach der Installation fügen Sie die notwendige using-Anweisung zu Ihren Controller- oder Serviceklassen hinzu, um auf den IronPDF-Namensraum zuzugreifen:

using IronPdf;
using System;
using System.Web;

using IronPdf;
using System;
using System.Web;

Imports IronPdf
Imports System
Imports System.Web

Für eine optimale Anzeigefunktionalität des Panels zum Anzeigen von PDF-Dateien konfigurieren Sie Ihre ASP.NET MVC- oder Core-Anwendung so, dass sie PDF-Inhalte ordnungsgemäß verarbeitet. Stellen Sie in Ihrer Program.cs-Datei sicher, dass Ihre Webanwendung statische Dateien ausliefern und die entsprechenden MIME-Typen verarbeiten kann. Der folgende Quellcode zeigt die grundlegende Konfiguration:

var builder = WebApplication.CreateBuilder(args);
// Add services to the container
builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();
var app = builder.Build();
// Configure the HTTP request pipeline
app.UseStaticFiles();
app.UseRouting();
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

var builder = WebApplication.CreateBuilder(args);
// Add services to the container
builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();
var app = builder.Build();
// Configure the HTTP request pipeline
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)
' Add services to the container
builder.Services.AddControllersWithViews()
builder.Services.AddRazorPages()

Dim app = builder.Build()
' Configure the HTTP request pipeline
app.UseStaticFiles()
app.UseRouting()
app.MapControllerRoute(
    name:="default",
    pattern:="{controller=Home}/{action=Index}/{id?}")

app.Run()

Diese Konfiguration bildet die Grundlage für die Bereitstellung von PDF-Inhalten über Ihre ASP.NET Core-Anwendung. Die Registrierung des Dienstes AddControllersWithViews() stellt sicher, dass Ihre Anwendung sowohl API-Endpunkte als auch das Rendern von Ansichten verarbeiten kann, was für die Anzeige von PDFs innerhalb von Panel-Steuerelementen unerlässlich ist. Die Routing-Konfiguration ermöglicht es Ihnen, spezifische Endpunkte für die PDF-Generierung und -Anzeige zu erstellen und so saubere URLs für Ihre in das Panel eingebetteten PDFs bereitzustellen. Weitere erweiterte Konfigurationsoptionen finden Sie in unserer vollständigen API-Dokumentation .

Wie kann eine PDF-Datei direkt in ASP.NET-Panels angezeigt werden?

Das Anzeigen von PDF-Dateien in ASP.NET Core-Panels erfordert die Erstellung einer Controller-Aktion, die PDF-Inhalte generiert oder abruft und diese direkt an den Browser streamt. Hier ist eine vollständige Implementierung, die die Kernfunktionalität zum Rendern von PDF-Seiten in ASP.NET-Panels demonstriert. Dieser Codeschnipsel zeigt die vollständige Lösung:

[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
    [HttpGet("display/{documentId}")]
    public IActionResult DisplayPdfInPanel(string documentId, object sender, EventArgs e)
    {
        // Create a new Chrome PDF renderer instance
        var renderer = new ChromePdfRenderer();
        // Generate a PDF file from HTML string
        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 generated PDF file is dynamically created and displayed directly in your panel.</p>
                    <p>Current page generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>";
        // Render the HTML string as a PDF document
        using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Convert to byte array for streaming
        byte[] pdfBytes = pdfDocument.BinaryData;
        // Set HTTP header for content disposition
        Response.Headers.Add("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, object sender, EventArgs e)
    {
        // Create a new Chrome PDF renderer instance
        var renderer = new ChromePdfRenderer();
        // Generate a PDF file from HTML string
        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 generated PDF file is dynamically created and displayed directly in your panel.</p>
                    <p>Current page generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>";
        // Render the HTML string as a PDF document
        using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Convert to byte array for streaming
        byte[] pdfBytes = pdfDocument.BinaryData;
        // Set HTTP header for content disposition
        Response.Headers.Add("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, sender As Object, e As EventArgs) As IActionResult
        ' Create a new Chrome PDF renderer instance
        Dim renderer As New ChromePdfRenderer()
        ' Generate a PDF file from HTML string
        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 generated PDF file is dynamically created and displayed directly in your panel.</p>
                    <p>Current page generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>"
        ' Render the HTML string as a PDF document
        Using pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
            ' Convert to byte array for streaming
            Dim pdfBytes As Byte() = pdfDocument.BinaryData
            ' Set HTTP header for content disposition
            Response.Headers.Add("Content-Disposition", $"inline; filename={filename}")
            Return File(pdfBytes, "application/pdf")
        End Using
    End Function
End Class

Der obige Code demonstriert mehrere Schlüsselkonzepte für die Anzeige von PDF-Dateien in Panels. Die Klasse ChromePdfRenderer dient als primäre Rendering-Engine von IronPDF auf Serverseite und verwendet intern einen Headless-Chrome-Browser, um eine genaue HTML-zu-PDF-Konvertierung zu gewährleisten. Sie können HTML-Inhalte dynamisch auf Basis der Daten Ihrer Anwendung generieren, sodass Sie im Handumdrehen maßgeschneiderte PDF-Dokumente erstellen können, die perfekt in ASP.NET-Panels angezeigt werden.

Die Methode RenderHtmlAsPdf übernimmt den Konvertierungsprozess und wandelt Ihr HTML in ein vollständig formatiertes PDF-Dokument um. Diese Methode erhält die CSS-Formatierung und gewährleistet so, dass Ihre PDF-Dateien beim Rendern in Panels das von Ihnen festgelegte visuelle Design beibehalten. Das resultierende PdfDocument-Objekt bietet über die Eigenschaft BinaryData Zugriff auf die Binärdaten der PDF-Datei. Für komplexere HTML-Strukturen können Sie auch Vorlagen und Styling-Optionen verwenden.

Die Konfiguration der Antwortfunktionen ist für die korrekte Anzeige von Bedienfeldern in ASP.NET-Anwendungen von entscheidender Bedeutung. Durch Setzen des HTTP-Headers Content-Disposition auf "inline" wird dem Browser mitgeteilt, dass die PDF-Datei direkt angezeigt werden soll, anstatt zum Herunterladen aufzufordern. Dies ermöglicht eine nahtlose Einbettung in Ihre Panel-Steuerelemente und sorgt so für ein reibungsloses Benutzererlebnis beim Anzeigen von PDF-Dokumenten in ASP.NET-Webanwendungen. Sie können auch Kopf- und Fußzeilen hinzufügen , um Ihre PDFs zu verbessern.

Um PDF-Dateien im Bedienfeld Ihrer Razor-Ansicht anzuzeigen, erstellen Sie eine einfache Bedienfeldstruktur mit Unterstützung für das Serverattribut "runat":

@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"
                        runat="server">
                </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"
                        runat="server">
                </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 building web applications and are typically written in a combination of HTML and C#.

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

Diese HTML-Struktur erzeugt ein responsives Panel, das einen iframe enthält, der auf Ihren PDF-Endpunkt verweist. Der iframe zeigt die serverseitig gerenderte PDF-Datei an, ohne dass clientseitige PDF-Viewer-Bibliotheken oder -Plugins erforderlich sind. Das Panel passt sich automatisch an verschiedene Bildschirmgrößen an, ohne dass die Lesbarkeit der PDF-Seiten beeinträchtigt wird, und ist daher ideal für die Anzeige von PDF-Dateien in ASP.NET Core-Anwendungen. Weitere Anpassungsmöglichkeiten finden Sie in unserer Dokumentation zu den Rendering-Einstellungen . Sie können auch benutzerdefinierte Ränder implementieren, um eine bessere Kontrolle über das Layout zu erhalten.

Wie integriere ich ein PDF-Dokument mit dynamischen Panels?

Dynamische Panel-Aktualisierungen und modale Popup-Anzeigen erfordern einen anspruchsvolleren Ansatz für die PDF-Integration. Laut der ASP.NET Core-Dokumentation von Microsoft sind asynchrone Muster unerlässlich für die Aufrechterhaltung reaktionsschneller Benutzeroberflächen. Hier erfahren Sie, wie Sie AJAX-basiertes PDF-Laden für responsive Benutzeroberflächen implementieren, die PDF-Dateien in Panels mit angemessener Fehlerbehandlung anzeigen:

[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
    try
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for optimal display
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;
        // Build HTML string from request data
        var htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<html><body>");
        htmlBuilder.Append($"<h2>{request.Title}</h2>");
        htmlBuilder.Append($"<div>{request.Content}</div>");
        // Add any dynamic data tables or charts
        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>");
        // Generate the PDF file asynchronously
        var pdfDocument = await Task.Run(() =>
            renderer.RenderHtmlAsPdf(htmlBuilder.ToString())
        );
        // Return PDF as base64 string for JavaScript handling
        byte[] byteArray = pdfDocument.BinaryData;
        var base64Pdf = Convert.ToBase64String(byteArray);
        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();
        // Configure rendering options for optimal display
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;
        // Build HTML string from request data
        var htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<html><body>");
        htmlBuilder.Append($"<h2>{request.Title}</h2>");
        htmlBuilder.Append($"<div>{request.Content}</div>");
        // Add any dynamic data tables or charts
        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>");
        // Generate the PDF file asynchronously
        var pdfDocument = await Task.Run(() =>
            renderer.RenderHtmlAsPdf(htmlBuilder.ToString())
        );
        // Return PDF as base64 string for JavaScript handling
        byte[] byteArray = pdfDocument.BinaryData;
        var base64Pdf = Convert.ToBase64String(byteArray);
        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 As New ChromePdfRenderer()
        ' Configure rendering options for optimal display
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        renderer.RenderingOptions.MarginLeft = 20
        renderer.RenderingOptions.MarginRight = 20
        ' Build HTML string from request data
        Dim htmlBuilder As New StringBuilder()
        htmlBuilder.Append("<html><body>")
        htmlBuilder.Append($"<h2>{request.Title}</h2>")
        htmlBuilder.Append($"<div>{request.Content}</div>")
        ' Add any dynamic data tables or charts
        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>")
        ' Generate the PDF file asynchronously
        Dim pdfDocument = Await Task.Run(Function() renderer.RenderHtmlAsPdf(htmlBuilder.ToString()))
        ' Return PDF as base64 string for JavaScript handling
        Dim byteArray As Byte() = pdfDocument.BinaryData
        Dim base64Pdf = Convert.ToBase64String(byteArray)
        Return Ok(New With {.success = True, .pdfData = base64Pdf})
    Catch ex As Exception
        Return BadRequest(New With {.success = False, .error = ex.Message})
    End Try
End Function

Dieser asynchrone Ansatz ermöglicht eine nicht blockierende PDF-Generierung, die für die Aufrechterhaltung von reaktionsfähigen Benutzeroberflächen beim Rendern von PDFs in ASP.NET-Panels unerlässlich ist. Die RenderingOptions Eigenschaft ermöglicht eine detaillierte Steuerung des PDF-Layouts, einschließlich Papierformat , Ränder und Ausrichtung . Diese Einstellungen stellen sicher, dass Ihre PDFs innerhalb der Panel-Einschränkungen optimal angezeigt werden. Für fortgeschrittene Anwendungsfälle können Sie Ihren dynamisch generierten PDFs auch Kopf- und Fußzeilen hinzufügen .

Die Methode akzeptiert ein Anfragemodell mit dynamischen Daten und zeigt, wie man PDFs aus Benutzereingaben oder Datenbankinhalten erstellt. Der HTML-Konstruktionsprozess zeigt, wie man Tabellen , Listen und andere strukturierte Daten programmatisch in PDFs einbindet und eignet sich daher perfekt für die Anzeige datengetriebener PDFs in ASP.NET Core-Panels. IronPDF unterstützt auch das Rendern von JavaScript und CSS für komplexere dynamische Inhalte.

Wie kann man mit verschiedenen PDF-Quellen umgehen?

IronPDF zeichnet sich durch die Generierung von PDF-Dateien aus verschiedenen Quellen aus, die jeweils für unterschiedliche Szenarien in der Panelanzeige geeignet sind. Sehen wir uns die wichtigsten Methoden zum Erstellen und Laden von PDF-Dokumenten an:

[HttpGet("from-html")]
 public IActionResult GenerateFromHtmlString(string reportType)
 {
     var renderer = new ChromePdfRenderer();
     // Load HTML template from your application
     var htmlTemplate = GetHtmlTemplate(reportType);
     // Safely get the user name, fallback to "Unknown" if null
     var userName = User?.Identity?.Name ?? "Unknown";
     // Inject dynamic data into HTML string
     var processedHtml = htmlTemplate
         .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
         .Replace("{{USER}}", userName)
         .Replace("{{REPORT_TYPE}}", reportType);
     // Render with custom CSS for specific page formatting
     renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
     var PDF = renderer.RenderHtmlAsPdf(processedHtml);
     // Save the generated PDF file
     string path = $"{reportType}.pdf";
     var webRootPath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot");
     var fullPath = Path.Combine(webRootPath, path.TrimStart('/').Replace('/', Path.DirectorySeparatorChar));
     pdf.SaveAs(fullPath);
     return File(pdf.BinaryData, "application/pdf");
 }
 // Add this private method inside the PdfPanel class to resolve CS0103
 private string GetHtmlTemplate(string reportType)
 {
     // Example: return a simple HTML template with placeholders
     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();
     // Load HTML template from your application
     var htmlTemplate = GetHtmlTemplate(reportType);
     // Safely get the user name, fallback to "Unknown" if null
     var userName = User?.Identity?.Name ?? "Unknown";
     // Inject dynamic data into HTML string
     var processedHtml = htmlTemplate
         .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
         .Replace("{{USER}}", userName)
         .Replace("{{REPORT_TYPE}}", reportType);
     // Render with custom CSS for specific page formatting
     renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
     var PDF = renderer.RenderHtmlAsPdf(processedHtml);
     // Save the generated PDF file
     string path = $"{reportType}.pdf";
     var webRootPath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot");
     var fullPath = Path.Combine(webRootPath, path.TrimStart('/').Replace('/', Path.DirectorySeparatorChar));
     pdf.SaveAs(fullPath);
     return File(pdf.BinaryData, "application/pdf");
 }
 // Add this private method inside the PdfPanel class to resolve CS0103
 private string GetHtmlTemplate(string reportType)
 {
     // Example: return a simple HTML template with placeholders
     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 System.IO
Imports Microsoft.AspNetCore.Mvc
Imports IronPdf

<HttpGet("from-html")>
Public Function GenerateFromHtmlString(reportType As String) As IActionResult
    Dim renderer As New ChromePdfRenderer()
    ' Load HTML template from your application
    Dim htmlTemplate As String = GetHtmlTemplate(reportType)
    ' Safely get the user name, fallback to "Unknown" if null
    Dim userName As String = If(User?.Identity?.Name, "Unknown")
    ' Inject dynamic data into HTML string
    Dim processedHtml As String = htmlTemplate _
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
        .Replace("{{USER}}", userName) _
        .Replace("{{REPORT_TYPE}}", reportType)
    ' Render with custom CSS for specific page formatting
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
    Dim pdf = renderer.RenderHtmlAsPdf(processedHtml)
    ' Save the generated PDF file
    Dim path As String = $"{reportType}.pdf"
    Dim webRootPath As String = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot")
    Dim fullPath As String = Path.Combine(webRootPath, path.TrimStart("/"c).Replace("/"c, Path.DirectorySeparatorChar))
    pdf.SaveAs(fullPath)
    Return File(pdf.BinaryData, "application/pdf")
End Function

' Add this private method inside the PdfPanel class to resolve CS0103
Private Function GetHtmlTemplate(reportType As String) As String
    ' Example: return a simple HTML template with placeholders
    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();
    // Configure for web page capture to display PDF pages
    renderer.RenderingOptions.ViewPortWidth = 1920;
    renderer.RenderingOptions.ViewPortHeight = 1080;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay(2000); // Wait for JS execution
    // Generate PDF from URL
    var PDF = await renderer.RenderUrlAsPdfAsync(url);
    // Return the generated PDF file
    string filename = "webpage.pdf";
    Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");
    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();
    // Configure for web page capture to display PDF pages
    renderer.RenderingOptions.ViewPortWidth = 1920;
    renderer.RenderingOptions.ViewPortHeight = 1080;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay(2000); // Wait for JS execution
    // Generate PDF from URL
    var PDF = await renderer.RenderUrlAsPdfAsync(url);
    // Return the generated PDF file
    string filename = "webpage.pdf";
    Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");
    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()
    ' Configure for web page capture to display PDF pages
    renderer.RenderingOptions.ViewPortWidth = 1920
    renderer.RenderingOptions.ViewPortHeight = 1080
    renderer.RenderingOptions.EnableJavaScript = True
    renderer.RenderingOptions.WaitFor.RenderDelay(2000) ' Wait for JS execution
    ' Generate PDF from URL
    Dim pdf = Await renderer.RenderUrlAsPdfAsync(url)
    ' Return the generated PDF file
    Dim filename As String = "webpage.pdf"
    Response.Headers.Append("Content-Disposition", $"inline; filename={filename}")
    Return File(pdf.BinaryData, "application/pdf")
End Function

public IActionResult OptimizedPdfGeneration()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
    var htmlTemplate = GetHtmlTemplate("improve");
    var processedHtml = htmlTemplate
       .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
       .Replace("{{USER}}", "Test")
       .Replace("{{REPORT_TYPE}}", "Improve");
    // Create the PDF document
    using (var PDF = renderer.RenderHtmlAsPdf(processedHtml))
    {
        // Process and return immediately
        byte[] byteArray = pdf.BinaryData;
        pdf.SaveAs("output.pdf");
        return File(byteArray, "application/pdf");
    }
}

public IActionResult OptimizedPdfGeneration()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
    var htmlTemplate = GetHtmlTemplate("improve");
    var processedHtml = htmlTemplate
       .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
       .Replace("{{USER}}", "Test")
       .Replace("{{REPORT_TYPE}}", "Improve");
    // Create the PDF document
    using (var PDF = renderer.RenderHtmlAsPdf(processedHtml))
    {
        // Process and return immediately
        byte[] byteArray = pdf.BinaryData;
        pdf.SaveAs("output.pdf");
        return File(byteArray, "application/pdf");
    }
}

Public Function OptimizedPdfGeneration() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.CreatePdfFormsFromHtml = False
    Dim htmlTemplate = GetHtmlTemplate("improve")
    Dim processedHtml = htmlTemplate _
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
        .Replace("{{USER}}", "Test") _
        .Replace("{{REPORT_TYPE}}", "Improve")
    ' Create the PDF document
    Using PDF = renderer.RenderHtmlAsPdf(processedHtml)
        ' Process and return immediately
        Dim byteArray As Byte() = PDF.BinaryData
        PDF.SaveAs("output.pdf")
        Return File(byteArray, "application/pdf")
    End Using
End Function

Warum IronPDF für Ihre PDF-Anzeigeanforderungen wählen?

IronPDF vereinfacht die komplexe Aufgabe der PDF-Anzeige in ASP.NET-Panel-Steuerelementen und macht sie zu einer unkomplizierten und wartungsfreundlichen Lösung. Durch die Verwendung von serverseitigem Rendering und die nahtlose Integration in die Architektur von ASP.NET Core können Sie eine zuverlässige PDF-Anzeigefunktionalität ohne clientseitige Abhängigkeiten oder Bedenken hinsichtlich der Browserkompatibilität erstellen. Die Möglichkeit, PDF-Dokumente direkt in Panels zu generieren , darzustellen und anzuzeigen, macht IronPDF zur idealen Wahl für moderne Webanwendungen. Dank der Unterstützung verschiedener PDF-Versionen und der PDF/A-Konformität stellt IronPDF sicher, dass Ihre Dokumente den Branchenstandards entsprechen.

Starten Sie noch heute Ihre kostenlose Testversion und erfahren Sie, wie IronPDF die PDF-Verarbeitung in Ihren ASP.NET-Anwendungen vereinfacht. Für den Anfang ist keine Kreditkarte erforderlich. Für den produktiven Einsatz können Sie unsere flexiblen Lizenzierungsoptionen nutzen, die sich an Ihre Bedürfnisse anpassen. Egal ob Sie HTML in PDF konvertieren , bestehende PDFs bearbeiten oder Sicherheitsfunktionen implementieren müssen, IronPDF bietet Ihnen alle Werkzeuge, die Sie für ein professionelles PDF-Management benötigen.

Die IronPDF-Lizenzseite zeigt die Preisstufen für Teamlizenzen von Lite (749 $) bis Unlimited (3.999 $) mit Entwickler-, Standort- und Projektbeschränkungen.