ASP.NET Afficher un PDF dans un panneau à l'aide d'IronPDF for .NET

Comment IronPDF simplifie-t-il l'affichage des fichiers PDF dans les panneaux?

IronPDF révolutionne la gestion des PDF dans ASP.NET Core en déportant entièrement le rendu côté serveur. Cette approche novatrice élimine les difficultés traditionnelles liées à l'affichage des PDF côté client, tout en vous offrant un contrôle efficace et programmable sur la génération et la présentation des documents grâce à son moteur de rendu Chrome .

Grâce au moteur de rendu côté serveur de la bibliothèque, vos PDF s'affichent de manière cohérente, quels que soient le navigateur, le système d'exploitation ou les plugins installés par l'utilisateur. Les utilisateurs n'ont plus besoin d'Adobe Reader, d'extensions de navigateur ou de tout autre logiciel tiers pour visualiser les fichiers PDF dans votre application . Cette universalité s'avère particulièrement précieuse dans les environnements d'entreprise où les politiques informatiques peuvent restreindre l'installation de plugins. Le moteur de rendu PDF de Chrome garantit une précision au pixel près lors de la conversion de HTML en PDF.

L'architecture d'IronPDF apporte également des avantages significatifs pour les scénarios de déploiement modernes. La bibliothèque offre une prise en charge multiplateforme fiable, fonctionnant de manière fluide sur les serveurs Windows , Linux et macOS . Le déploiement de conteneurs est entièrement pris en charge, ce qui rend IronPDF idéal pour les applications exécutées dans des conteneurs Docker ou des clusters Kubernetes. Cette flexibilité garantit que votre fonctionnalité d'affichage PDF fonctionne de manière cohérente dans les environnements de développement, de préproduction et de production sur Azure ou AWS .

! Présentation des fonctionnalités d'IronPDF, réparties en quatre catégories principales : Créer des PDF, Convertir des PDF, Modifier des PDF, et Signer et sécuriser des PDF, avec une liste détaillée des fonctionnalités sous chaque catégorie.

Comment configurer IronPDF pour l'affichage sur panneau?

La mise en œuvre d'IronPDF dans votre projet ASP.NET Core ne nécessite que quelques étapes simples. Tout d'abord, ouvrez Visual Studio et accédez à l'Explorateur de solutions. Cliquez avec le bouton droit sur votre projet et sélectionnez " Gérer le gestionnaire de packages NuGet " pour installer le package NuGet IronPDF . Vous pouvez également exécuter le code suivant dans la console du gestionnaire de paquets :

Install-Package IronPdf

! Console du gestionnaire de packages affichant le processus d'installation du package NuGet IronPdf avec plusieurs dépendances en cours de téléchargement

Sinon, pour vos applications .NET Framework ou .NET Core , vous pouvez utiliser l'interface de ligne de commande .NET pour télécharger le package :

dotnet add package IronPdf

Une fois installé, ajoutez l'instruction using nécessaire à vos classes de contrôleur ou de service pour accéder à l' espace de noms IronPDF :

using IronPdf;
using System;
using System.Web;

using IronPdf;
using System;
using System.Web;

Imports IronPdf
Imports System
Imports System.Web

Pour un affichage optimal des fichiers PDF , configurez votre application ASP.NET MVC ou Core pour gérer correctement le contenu PDF. Dans votre fichier Program.cs, assurez-vous que votre application web peut servir des fichiers statiques et gérer les types MIME appropriés. Le code source suivant illustre la configuration de base :

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()

Cette configuration établit les bases pour servir du contenu PDF par le biais de votre application ASP.NET Core. L'enregistrement du service AddControllersWithViews() garantit que votre application peut gérer à la fois les points de terminaison API et le rendu des vues, ce qui est essentiel pour afficher des PDF dans les contrôles de panneau . La configuration de routage vous permet de créer des points de terminaison spécifiques pour la génération et l'affichage de PDF , en fournissant des URL propres pour vos PDF intégrés aux panneaux. Pour des options de configuration plus avancées, consultez notre documentation API complète.

Comment afficher un fichier PDF directement dans les panneaux ASP.NET?

L'affichage de fichiers PDF dans les panneaux ASP.NET Core implique la création d'une action de contrôleur qui génère ou récupère le contenu PDF et le diffuse directement au navigateur. Voici une implémentation complète qui illustre les fonctionnalités de base pour le rendu de pages PDF dans des panneaux ASP.NET. Cet extrait de code montre la solution complète :

[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

Le code ci-dessus démontre plusieurs concepts clés pour l'affichage de fichiers PDF dans des panneaux. La classe ChromePdfRenderer sert de moteur de rendu principal d'IronPDF côté serveur, utilisant un navigateur Chrome sans interface graphique en interne pour garantir une conversion HTML vers PDF précise. Vous pouvez générer dynamiquement du contenu HTML à partir des données de votre application, ce qui vous permet de créer à la volée des documents PDF personnalisés qui s'affichent parfaitement dans les panneaux ASP.NET.

La méthode RenderHtmlAsPdf gère le processus de conversion, transformant votre HTML en un document PDF entièrement formaté. Cette méthode préserve le style CSS , garantissant ainsi que vos fichiers PDF conservent la conception visuelle que vous spécifiez lors du rendu dans des panneaux. L'objet PdfDocument résultant permet d'accéder aux données binaires du fichier PDF grâce à la propriété BinaryData. Pour les structures HTML plus complexes, vous pouvez également utiliser des modèles et des options de style .

La configuration de la réponse s'avère cruciale pour un affichage correct des panneaux dans les applications ASP.NET. Définir l'en-tête HTTP Content-Disposition sur " inline " indique au navigateur d'afficher directement le PDF au lieu de demander son téléchargement. Cela permet une intégration fluide dans vos contrôles de panneau, créant ainsi une expérience utilisateur optimale lors de la consultation de documents PDF dans les applications Web ASP.NET. Vous pouvez également ajouter des en-têtes et des pieds de page pour améliorer vos PDF.

Pour afficher des fichiers PDF dans le panneau de votre vue Razor , créez une structure de panneau simple avec prise en charge de l'attribut serveur 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.

Cette structure HTML crée un panneau adaptatif contenant une iframe qui pointe vers votre point de terminaison PDF. L' iframe affiche le fichier PDF généré par le serveur sans nécessiter de bibliothèques ou de plugins de visualisation PDF côté client. Le panneau s'adapte automatiquement aux différentes tailles d'écran tout en conservant la lisibilité des pages PDF, ce qui le rend idéal pour l'affichage de fichiers PDF dans les applications ASP.NET Core. Pour plus d'options de personnalisation, consultez notre documentation sur les paramètres de rendu . Vous pouvez également implémenter des marges personnalisées pour un meilleur contrôle de la mise en page.

Comment intégrer un document PDF avec des panneaux dynamiques ?

Les mises à jour dynamiques des panneaux et l'affichage de fenêtres contextuelles modales nécessitent une approche plus sophistiquée de l'intégration des PDF. Selon la documentation ASP.NET Core de Microsoft , les modèles asynchrones sont essentiels pour maintenir des interfaces réactives. Voici comment mettre en œuvre le chargement de PDF basé sur AJAX pour des interfaces utilisateur réactives qui affichent des fichiers PDF dans des panneaux avec une gestion appropriée des erreurs :

[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

Cette approche asynchrone permet de générer des PDF sans blocage, ce qui est essentiel pour maintenir des interfaces utilisateur réactives lors du rendu des PDF dans les panneaux ASP.NET. La propriété RenderingOptions offre un contrôle précis sur la mise en page du PDF, notamment la taille du papier , les marges et l'orientation . Ces paramètres garantissent que vos PDF s'affichent de manière optimale dans les limites du panneau. Pour les scénarios avancés, vous pouvez également ajouter des en-têtes et des pieds de page à vos PDF générés dynamiquement.

La méthode accepte un modèle de requête contenant des données dynamiques, démontrant comment construire des PDF à partir d'une entrée utilisateur ou du contenu d'une base de données. Le processus de construction HTML montre comment intégrer par programmation des tableaux , des listes et d'autres données structurées dans vos PDF, ce qui le rend idéal pour afficher des PDF basés sur des données dans des panneaux ASP.NET Core. IronPDF prend également en charge le rendu JavaScript et CSS pour les contenus dynamiques plus complexes.

Comment gérer différentes sources de PDF?

IronPDF excelle dans la génération de fichiers PDF à partir de diverses sources, chacune adaptée à différents scénarios d'affichage sur panneau. Examinons les principales approches de la création et du chargement de documents PDF :

[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

Pourquoi choisir IronPDF pour vos besoins d'affichage de PDF ?

IronPDF simplifie la tâche complexe d'affichage des PDF dans les contrôles de panneau ASP.NET en une solution simple et facile à maintenir. Grâce au rendu côté serveur et à une intégration fluide avec l'architecture d'ASP.NET Core, vous pouvez créer une fonctionnalité d'affichage PDF fiable sans dépendances côté client ni problèmes de compatibilité avec les navigateurs. La possibilité de générer , de rendre et d'afficher des documents PDF directement dans des panneaux fait d'IronPDF le choix idéal pour les applications web modernes. Grâce à sa compatibilité avec différentes versions de PDF et sa conformité à la norme PDF/A , IronPDF garantit que vos documents répondent aux normes de l'industrie.

Démarrez votre essai gratuit dès aujourd'hui pour découvrir comment IronPDF simplifie le traitement des PDF dans vos applications ASP.NET. Aucune carte de crédit n'est requise pour commencer. Pour les déploiements en production, découvrez nos options de licence flexibles qui s'adaptent à vos besoins. Que vous ayez besoin de convertir du HTML en PDF , de modifier des PDF existants ou de mettre en œuvre des fonctionnalités de sécurité , IronPDF vous fournit tous les outils nécessaires à une gestion professionnelle des PDF.

La page de licences IronPDF présente les différents niveaux de prix des licences d'équipe, allant de Lite (749 $) à Illimité (3 999 $), avec des limites par développeur, emplacement et projet.