IronPDF permet une conversion HTML vers PDF transparente dans ASP.NET Core grâce à un moteur de rendu basé sur Chrome qui préserve la mise en forme, le CSS et le JavaScript— essentiels pour générer des factures, des rapports et des documents téléchargeables dans les applications web modernes.
La conversion de documents HTML dynamiques en documents PDF est une exigence fondamentale des applications ASP.NET modernes. Que vous génériez des factures, créiez des rapports ou produisiez des fichiers téléchargeables, la transformation du contenu HTML en PDF Professional est essentielle pour offrir une expérience utilisateur soignée.
IronPDF simplifie ce processus de conversion en fournissant un moteur de rendu robuste basé sur Chrome qui préserve parfaitement votre formatage HTML, votre style CSS et vos fonctionnalités JavaScript dans les documents résultants. Ce tutoriel vous présente des méthodes efficaces pour convertir du HTML en PDF dans les applications ASP.NET Core à l'aide de la bibliothèque IronPDF .
Les applications ASP.NET Core génèrent souvent du contenu HTML dynamique que les utilisateurs doivent télécharger, partager ou archiver au format PDF. La conversion HTML en PDF offre plusieurs avantages clés par rapport au simple enregistrement de pages web ou la prise de captures d'écran.
Les fichiers PDF conservent une mise en page cohérente sur tous les appareils et plateformes, garantissant ainsi que vos factures aient une apparence identique, qu'elles soient consultées sur Windows, Mac ou appareils mobiles. Elles sont idéales pour les documents nécessitant des signatures numériques , des paramètres de sécurité ou une impression Professional . La conversion côté serveur élimine le besoin pour les utilisateurs d'installer un logiciel spécifique et offre un meilleur contrôle sur le résultat final.
Les cas d'utilisation courants incluent la génération de rapports financiers à partir des données du tableau de bord , la création de factures téléchargeables à partir des informations de commande, la production de billets et de laissez-passer avec des codes QR et la conversion des soumissions de formulaires en enregistrements permanents. En gérant la conversion sur le serveur, vous garantissez des résultats cohérents, quelles que soient les capacités du navigateur ou de l'appareil de l'utilisateur. Le format d'archivage PDF/A assure la conservation à long terme des documents, tandis que la compression PDF réduit la taille des fichiers pour un stockage et une transmission efficaces.
Pour les ingénieurs DevOps, cette approche côté serveur s'intègre parfaitement avec les déploiements conteneurisés et les pipelines CI/CD, assurant une génération de PDF fiable à travers différents environnements. Les fonctionnalités d'optimisation des performances permettent une utilisation efficace des ressources dans les déploiements en production. Les guides de déploiement Azure et l'intégration AWS Lambda fournissent des stratégies d'optimisation spécifiques à chaque plateforme.
Commencer avec IronPDF dans votre projet ASP.NET Core est simple. La bibliothèque prend en charge .NET Core 2.0 et versions ultérieures, ainsi que .NET 5, 6, 7 et 8, ce qui la rend compatible avec toutes les applications ASP.NET Core modernes. Pour les environnements conteneurisés, IronPDF fournit une prise en charge officielle de Docker . La présentation générale de l'installation couvre tous les scénarios de déploiement.
La méthode la plus rapide pour ajouter IronPDF à votre projet consiste à utiliser le gestionnaire de packages NuGet dans Visual Studio. Cliquez avec le bouton droit sur votre projet dans l'Explorateur de solutions, sélectionnez "Gérer les packages NuGet" et recherchez IronPDF. Cliquez sur Installer sur la dernière version pour l'ajouter à votre projet. Pour des instructions d'installation détaillées, consultez le guide d'installation IronPDF . D'autres méthodes existent, comme l'utilisation de Windows Installer ou d'une configuration NuGet avancée .
Pour les déploiements conteneurisés, utilisez le package IronPdf.Slim qui réduit la taille initiale du déploiement :
Cette approche est avantageuse pour les déploiements AWS Lambda ou Azure Functions, où les contraintes de taille des packages sont critiques. La comparaison entre le moteur natif et le moteur distant permet de choisir la stratégie de déploiement optimale.
Une fois installé, ajoutez l'espace de noms IronPDF à tout fichier C# où vous travaillerez avec la génération de PDF :
using IronPdf;Imports IronPdfCette instruction d'importation vous donne accès à toute la fonctionnalité d'IronPDF, y compris la classe ChromePdfRenderer pour la conversion HTML et diverses options de configuration pour personnaliser votre sortie. La documentation de référence de l'API fournit une documentation complète pour toutes les classes et méthodes disponibles.
Pour la plupart des applications ASP.NET Core, IronPDF fonctionne immédiatement après l'installation sans configuration supplémentaire. Cependant, vous pouvez définir des options globales dans votre fichier Program.cs ou Startup.cs :
// Optional: Configure IronPDF settings
Installation.TempFolderPath = @"C:\Temp\IronPdf\";
Installation.LinuxAndDockerDependenciesAutoConfig = true;
// Configure license key for production
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Optional: Configure IronPDF settings
Installation.TempFolderPath = "C:\Temp\IronPdf\"
Installation.LinuxAndDockerDependenciesAutoConfig = True
' Configure license key for production
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"Ces options de configuration permettent d'optimiser IronPDF pour votre environnement d'hébergement spécifique, qu'il fonctionne sous Windows , Linux ou dans des conteneurs Docker. Veillez à ce que les fichiers de script et d'application ne se trouvent pas dans le même répertoire afin d'éviter les conflits. Le guide des clés de licence explique la configuration appropriée des licences, tandis que le dépannage des problèmes de déploiement aide à résoudre les problèmes courants.
Pour les déploiements en production, envisagez d'ajouter des points de terminaison de contrôle d'intégrité pour surveiller les services de génération de PDF :
// Add health checks for monitoring
services.AddHealthChecks()
.AddCheck("pdf-service", () =>
{
try
{
var renderer = new ChromePdfRenderer();
var test = renderer.RenderHtmlAsPdf("<p>Health Check</p>");
return HealthCheckResult.Healthy();
}
catch (Exception ex)
{
return HealthCheckResult.Unhealthy(ex.Message);
}
});' Add health checks for monitoring
services.AddHealthChecks() _
.AddCheck("pdf-service", Function()
Try
Dim renderer = New ChromePdfRenderer()
Dim test = renderer.RenderHtmlAsPdf("<p>Health Check</p>")
Return HealthCheckResult.Healthy()
Catch ex As Exception
Return HealthCheckResult.Unhealthy(ex.Message)
End Try
End Function)Pour les déploiements Kubernetes , mettez en œuvre des sondes de disponibilité et de vivacité afin de garantir la disponibilité du service. Le guide d'assistance à la performance propose des stratégies d'optimisation supplémentaires.
Lancez Visual Studio et sélectionnez le type de projet ASP.NET qui correspond le mieux à vos besoins. Pour l'exemple d'aujourd'hui, je vais créer une application web ASP.NET Core (Modèle-vue-contrôleur).
Ensuite, entrez le nom de votre projet et choisissez l'emplacement pour héberger le projet.
Enfin, choisissez votre framework .NET pour le projet, et modifiez tous les paramètres supplémentaires pour le projet, tels que le type d'authentification, ou l'activation du support des conteneurs et de docker.
Pour créer un nouveau contrôleur pour héberger notre code HTML à PDF, faites d'abord un clic droit sur le dossier "Controllers" dans l'explorateur de solution et choisissez "Ajouter -> Contrôleur".
Cela ouvrira une nouvelle fenêtre, dans laquelle vous pourrez choisir la forme de contrôleur que vous souhaitez ajouter au projet. Nous avons choisi un Contrôleur MVC vide.
Enfin, donnez un nom au nouveau contrôleur et cliquez sur "Ajouter" pour l'ajouter à notre projet.
L'opération la plus fondamentale d' IronPDF consiste à convertir directement des chaînes HTML en documents PDF . Cette approche fonctionne parfaitement lors de la génération dynamique de contenu HTML dans votre application ASP.NET ou lors de l'utilisation de modèles. Le tutoriel complet couvre des scénarios avancés.
// Create a PDF converter instance
var renderer = new ChromePdfRenderer();
// Convert HTML string to PDF document
var pdf = renderer.RenderHtmlAsPdf("<h1>Sales Report</h1><p>Generated on: " + DateTime.Now + "</p>");
// Save the resultant PDF document to a file
pdf.SaveAs("report.pdf");' Create a PDF converter instance
Dim renderer = New ChromePdfRenderer()
' Convert HTML string to PDF document
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Sales Report</h1><p>Generated on: " & DateTime.Now & "</p>")
' Save the resultant PDF document to a file
pdf.SaveAs("report.pdf")Ce code crée une nouvelle instance ChromePdfRenderer qui utilise le moteur Chromium pour rendre votre contenu HTML. La méthode RenderHtmlAsPdf accepte toute chaîne HTML valide et retourne un objet PdfDocument. Vous pouvez ensuite enregistrer ce document sur disque ou le diffuser directement aux utilisateurs sous forme de tableau d'octets. Découvrez plus d'informations sur la classe ChromePdfRenderer et ses fonctionnalités. Le guide de création de PDF propose des méthodes de création supplémentaires.
Pour les environnements de production à forte concurrence, mettez en œuvre une gestion des ressources appropriée :
// Implement using statement for proper disposal
using (var renderer = new ChromePdfRenderer())
{
// Configure for optimal performance
renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Use memory stream for better resource management
using (var ms = new MemoryStream())
{
pdf.SaveAs(ms);
return ms.ToArray();
}
}' Implement using statement for proper disposal
Using renderer As New ChromePdfRenderer()
' Configure for optimal performance
renderer.RenderingOptions.CreatePdfFormsFromHtml = False
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
renderer.RenderingOptions.PrintHtmlBackgrounds = True
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
' Use memory stream for better resource management
Using ms As New MemoryStream()
pdf.SaveAs(ms)
Return ms.ToArray()
End Using
End UsingLe guide sur les flux de mémoire explique la gestion efficace des fichiers PDF en mémoire. Pour les opérations asynchrones , utilisez les méthodes de rendu asynchrones afin d'améliorer le débit.
IronPDF prend entièrement en charge le style CSS et peut intégrer des images provenant de diverses sources. Le convertisseur gère tous les éléments avec une fidélité totale, y compris les différentes balises et URL d'images . La prise en charge du format SVG garantit un rendu parfait des images vectorielles.
var html = @"
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
h1 { color: #2c3e50; border-bottom: 2px solid #3498db; }
.highlight { background-color: #f1c40f; padding: 5px; }
</style>
<h1>Monthly Report</h1>
<p>This HTML document includes <span class='highlight'>highlighted text</span> and styling.</p>
<img src='data:image/png;base64,iVBORw0KGgoAAAANS...' alt='Logo' />";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);Dim html As String = "
<style>
body { font-family: Arial, sans-serif; margin: 40px; }
h1 { color: #2c3e50; border-bottom: 2px solid #3498db; }
.highlight { background-color: #f1c40f; padding: 5px; }
</style>
<h1>Monthly Report</h1>
<p>This HTML document includes <span class='highlight'>highlighted text</span> and styling.</p>
<img src='data:image/png;base64,iVBORw0KGgoAAAANS...' alt='Logo' />"
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)Le moteur de rendu traite les styles en ligne, les fichiers CSS et même les images encodées en base64 . Cela garantit que vos pages conservent l'apparence exacte de votre contenu HTML, y compris les fonctionnalités CSS3 modernes comme Flexbox et les mises en page en grille . La conversion préserve toutes les balises et le style sans générer de pages blanches. Les polices Web et les polices d'icônes sont entièrement prises en charge, y compris Google Fonts .
Pour les environnements conteneurisés, assurez-vous que les ressources externes sont accessibles ou intégrées :
// Configure base URL for resource loading
renderer.RenderingOptions.BaseUrl = new Uri("___PROTECTED_URL_105___");
// Or embed resources using data URIs for self-contained PDFs
var htmlWithEmbeddedResources = @"
<style>
@font-face {
font-family: 'CustomFont';
src: url(data:font/woff2;base64,...) format('woff2');
}
</style>";' Configure base URL for resource loading
renderer.RenderingOptions.BaseUrl = New Uri("___PROTECTED_URL_105___")
' Or embed resources using data URIs for self-contained PDFs
Dim htmlWithEmbeddedResources As String = "
<style>
@font-face {
font-family: 'CustomFont';
src: url(data:font/woff2;base64,...) format('woff2');
}
</style>"Le guide des URL de base explique les stratégies appropriées de référencement des ressources. Pour la prise en charge des langues internationales , assurez-vous d'un encodage UTF-8 correct.
La conversion de vues ASP.NET Core complètes en PDF est courante, notamment pour la génération de rapports basés sur des modèles existants. IronPDF propose plusieurs approches pour ce scénario, que ce soit avec une seule page ou plusieurs pages . Les tutoriels de conversion CSHTML vers PDF couvrent les implémentations spécifiques à chaque framework.
Dans votre contrôleur ASP.NET Core , générez une vue en HTML, puis convertissez-la en PDF en utilisant les puissantes capacités de rendu d'IronPDF :
[HttpGet]
public async Task<IActionResult> DownloadPdf()
{
var invoiceModel = new InvoiceModel
{
InvoiceNumber = 12345,
Date = DateTime.Now,
CustomerName = "Acme Corporation",
Items = new List<InvoiceItem>
{
new InvoiceItem { Description = "Service", Quantity = 1, Price = 100.0 }
},
Total = 100.0
};
// Render the view to HTML string
var htmlContent = await RenderViewToString("Invoice", invoiceModel);
// Convert HTML to PDF
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
// Return PDF to browser
var contentType = "application/pdf";
var fileName = $"invoice_{DateTime.Now:yyyyMMdd}.pdf";
return File(pdf.BinaryData, contentType, fileName);
}
private async Task<string> RenderViewToString(string viewName, object model)
{
ViewData.Model = model;
using (var writer = new StringWriter())
{
var viewResult = viewEngine.FindView(ControllerContext, viewName, false);
var viewContext = new ViewContext(
ControllerContext,
viewResult.View,
ViewData,
TempData,
writer,
new HtmlHelperOptions()
);
await viewResult.View.RenderAsync(viewContext);
return writer.GetStringBuilder().ToString();
}
}Imports System
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
<HttpGet>
Public Async Function DownloadPdf() As Task(Of IActionResult)
Dim invoiceModel = New InvoiceModel With {
.InvoiceNumber = 12345,
.Date = DateTime.Now,
.CustomerName = "Acme Corporation",
.Items = New List(Of InvoiceItem) From {
New InvoiceItem With {.Description = "Service", .Quantity = 1, .Price = 100.0}
},
.Total = 100.0
}
' Render the view to HTML string
Dim htmlContent = Await RenderViewToString("Invoice", invoiceModel)
' Convert HTML to PDF
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
' Return PDF to browser
Dim contentType = "application/pdf"
Dim fileName = $"invoice_{DateTime.Now:yyyyMMdd}.pdf"
Return File(pdf.BinaryData, contentType, fileName)
End Function
Private Async Function RenderViewToString(viewName As String, model As Object) As Task(Of String)
ViewData.Model = model
Using writer = New StringWriter()
Dim viewResult = viewEngine.FindView(ControllerContext, viewName, False)
Dim viewContext = New ViewContext(
ControllerContext,
viewResult.View,
ViewData,
TempData,
writer,
New HtmlHelperOptions()
)
Await viewResult.View.RenderAsync(viewContext)
Return writer.GetStringBuilder().ToString()
End Using
End FunctionCette approche consiste d'abord à convertir votre vue Razor en une chaîne HTML , puis à la convertir en PDF. Le fichier PDF est renvoyé sous forme de téléchargement dans le navigateur de l'utilisateur, avec un nom de fichier approprié. Cela fonctionne parfaitement avec les fichiers ASPX et les vues Razor modernes. Pour les pages Razor , utilisez les méthodes de rendu dédiées. Le guide du framework MVC couvre les anciennes versions ASP.NET .
Pour les déploiements en production, mettez en œuvre la mise en cache afin de réduire la charge du serveur :
private readonly IMemoryCache _cache;
[HttpGet]
public async Task<IActionResult> DownloadCachedPdf(int invoiceId)
{
var cacheKey = $"invoice_pdf_{invoiceId}";
if (!_cache.TryGetValue(cacheKey, out byte[] pdfBytes))
{
// Generate PDF if not cached
var htmlContent = await RenderViewToString("Invoice", model);
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdfBytes = pdf.BinaryData;
// Cache for 1 hour
_cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1));
}
return File(pdfBytes, "application/pdf", $"invoice_{invoiceId}.pdf");
}Private ReadOnly _cache As IMemoryCache
<HttpGet>
Public Async Function DownloadCachedPdf(invoiceId As Integer) As Task(Of IActionResult)
Dim cacheKey = $"invoice_pdf_{invoiceId}"
Dim pdfBytes As Byte() = Nothing
If Not _cache.TryGetValue(cacheKey, pdfBytes) Then
' Generate PDF if not cached
Dim htmlContent = Await RenderViewToString("Invoice", model)
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdfBytes = pdf.BinaryData
' Cache for 1 hour
_cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1))
End If
Return File(pdfBytes, "application/pdf", $"invoice_{invoiceId}.pdf")
End FunctionLe guide de rendu sans interface graphique explique comment générer des PDF sans contexte d'interface graphique, ce qui est idéal pour les services en arrière-plan.
Pour les pages web existantes, utilisez IronPDF pour transformer directement n'importe quelle URL en PDF . Il vous suffit de fournir une adresse HTTP ou HTTPS :
[HttpGet]
public IActionResult GeneratePdfFromUrl()
{
var renderer = new ChromePdfRenderer();
// Convert a specified URL to PDF document
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_106___");
// Stream the PDF file to the browser
return File(pdf.BinaryData, "application/pdf", "invoice.pdf");
}<HttpGet>
Public Function GeneratePdfFromUrl() As IActionResult
Dim renderer = New ChromePdfRenderer()
' Convert a specified URL to PDF document
Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_106___")
' Stream the PDF file to the browser
Return File(pdf.BinaryData, "application/pdf", "invoice.pdf")
End FunctionCette méthode fonctionne bien lorsque vous disposez déjà de pages web bien formatées et que vous souhaitez les proposer sous forme de PDF téléchargeables. La bibliothèque gère toutes les ressources externes, y compris les feuilles de style, les scripts et les images, assurant ainsi un rendu complet. Le convertisseur renvoie un code d'état HTTP approprié s'il rencontre une URL invalide. Pour les pages contenant beaucoup de JavaScript , configurez des délais de rendu appropriés.
Pour les environnements conteneurisés, configurez les paramètres réseau en conséquence :
// Configure for Docker/Kubernetes environments
renderer.RenderingOptions.Timeout = 60000; // 60 second timeout
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor = new WaitFor()
{
RenderDelay = 500, // Wait 500ms after page load
NetworkIdle = IronPdf.Engines.Chrome.NetworkIdle.NetworkIdle2
};' Configure for Docker/Kubernetes environments
renderer.RenderingOptions.Timeout = 60000 ' 60 second timeout
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor = New WaitFor() With {
.RenderDelay = 500, ' Wait 500ms after page load
.NetworkIdle = IronPdf.Engines.Chrome.NetworkIdle.NetworkIdle2
}Le guide des options de rendu fournit des informations de configuration complètes. Pour le contenu WebGL , activez l'accélération GPU.
Lors de la conversion de pages authentifiées avec l'authentification par formulaire .NET ou d'autres mécanismes de sécurité, transmettez des cookies ou des en-têtes pour maintenir la session utilisateur. Cela empêche la redirection vers les écrans de connexion pendant la conversion :
var renderer = new ChromePdfRenderer();
// Set cookies for authenticated requests with user database credentials
renderer.RenderingOptions.CustomCookies.Add("auth_token", Request.Cookies["auth_token"]);
// Convert protected web pages to PDF
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_107___");Dim renderer As New ChromePdfRenderer()
' Set cookies for authenticated requests with user database credentials
renderer.RenderingOptions.CustomCookies.Add("auth_token", Request.Cookies("auth_token"))
' Convert protected web pages to PDF
Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_107___")Cela permet de convertir les contenus protégés en PDF tout en préservant la sécurité. Le processus de conversion respecte l'authentification de base et l'authentification par formulaire de votre application, empêchant ainsi tout accès non autorisé aux documents sensibles. Vous pouvez également passer des arguments de nom d'utilisateur et de mot de passe lorsque nécessaire pour les scénarios d'authentification de base. Le guide de gestion des cookies explique la gestion avancée des cookies. Pour l'authentification Kerberos , configurez les informations d'identification appropriées.
Pour les architectures de microservices, envisagez l'authentification de service à service :
// Add service authentication headers
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Service-Token", GetServiceToken());
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Request-ID", Activity.Current?.Id);
// Configure for internal service mesh
renderer.RenderingOptions.BaseUrl = new Uri("___PROTECTED_URL_108___");' Add service authentication headers
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Service-Token", GetServiceToken())
renderer.RenderingOptions.ExtraHttpHeaders.Add("X-Request-ID", Activity.Current?.Id)
' Configure for internal service mesh
renderer.RenderingOptions.BaseUrl = New Uri("___PROTECTED_URL_108___")Le traitement des données de formulaire avant la génération du PDF est une pratique courante dans les applications ASP.NET : les confirmations de commande, les bons de livraison et les reçus suivent tous ce modèle. L'approche consiste à lier les données du formulaire envoyé à un modèle, à construire une chaîne HTML à partir de ce modèle, puis à générer un PDF à partir de cette chaîne :
[HttpPost]
public IActionResult ProcessFormToPdf(OrderModel model)
{
var renderer = new ChromePdfRenderer();
string html = $@"
<h2>Order Confirmation</h2>
<p>Customer: {model.CustomerName}</p>
<p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
<ul>
{string.Join("", model.Items.Select(i => $"<li>{i.Name} -- ${i.Price}</li>"))}
</ul>
<p><strong>Total: ${model.Total}</strong></p>";
var pdf = renderer.RenderHtmlAsPdf(html);
string fileName = $"order-{model.OrderId}.pdf";
return File(pdf.BinaryData, "application/pdf", fileName);
}Imports System
Imports System.Linq
Imports Microsoft.AspNetCore.Mvc
<HttpPost>
Public Function ProcessFormToPdf(model As OrderModel) As IActionResult
Dim renderer = New ChromePdfRenderer()
Dim html As String = $"
<h2>Order Confirmation</h2>
<p>Customer: {model.CustomerName}</p>
<p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
<ul>
{String.Join("", model.Items.Select(Function(i) $"<li>{i.Name} -- ${i.Price}</li>"))}
</ul>
<p><strong>Total: ${model.Total}</strong></p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim fileName As String = $"order-{model.OrderId}.pdf"
Return File(pdf.BinaryData, "application/pdf", fileName)
End Function
Pour des scénarios de documents plus avancés, vous pouvez intégrer des formulaires PDF ou modifier des modèles PDF existants avec des champs préremplis. La bibliothèque prend également en charge les signatures numériques pour les documents et contrats juridiques, vous permettant d'ajouter des signatures cryptographiquement vérifiables à tout document généré.
L'un des aspects importants à prendre en compte lors de l'intégration de données utilisateur dans des chaînes HTML est leur assainissement. Veillez toujours à échapper les chaînes de caractères fournies par l'utilisateur avant de les insérer dans le code HTML afin d'éviter les problèmes d'injection. Un appel simple System.Web.HttpUtility.HtmlEncode(model.CustomerName) sur chaque champ garde le modèle sécurisé avant de le passer au moteur de rendu.
IronPDF offre de nombreuses options de personnalisation pour contrôler la manière dont vos documents sont générés à partir de HTML. Ces paramètres vous aident à créer des PDF Professional qui répondent à des exigences spécifiques en matière de mise en page et de formatage. Les exemples de paramètres de rendu illustrent des implémentations pratiques.
var renderer = new ChromePdfRenderer();
// Set default page size for PDF pages
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
// Control page width and margins for the resultant PDF document
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;Dim renderer As New ChromePdfRenderer()
' Set default page size for PDF pages
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
' Control page width and margins for the resultant PDF document
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20Ces paramètres contrôlent la mise en page de vos pages. Vous pouvez choisir parmi les formats de papier standard ou définir des dimensions personnalisées , choisir l'orientation portrait ou paysage et ajuster les marges en fonction de vos exigences de conception. Le système de modèles graphiques garantit un style cohérent sur toutes les pages. Pour les sauts de page , utilisez les propriétés CSS afin de contrôler le flux de contenu.
Pour les considérations relatives à la conception adaptative :
// Configure viewport for mobile-friendly PDFs
renderer.RenderingOptions.ViewportWidth = 1024;
renderer.RenderingOptions.ViewportHeight = 768;
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.FitToPaperMode = FitToPaperModes.Zoom;
renderer.RenderingOptions.Zoom = 100;' Configure viewport for mobile-friendly PDFs
renderer.RenderingOptions.ViewportWidth = 1024
renderer.RenderingOptions.ViewportHeight = 768
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.FitToPaperMode = FitToPaperModes.Zoom
renderer.RenderingOptions.Zoom = 100Le guide de configuration de la fenêtre d'affichage explique les paramètres optimaux pour différents types de contenu. Pour un affichage en niveaux de gris , activez l'option de rendu appropriée.
L'ajout d'en-têtes et de pieds de page cohérents améliore l'aspect Professional de vos documents :
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align: center'>Company Report</div>",
MaxHeight = 20
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
HtmlFragment = "<div style='text-align: center'>Page {page} of {total-pages}</div>",
MaxHeight = 20
};Imports System
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align: center'>Company Report</div>",
.MaxHeight = 20
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
.HtmlFragment = "<div style='text-align: center'>Page {page} of {total-pages}</div>",
.MaxHeight = 20
}Les en-têtes et les pieds de page prennent en charge la mise en forme HTML avec des espaces réservés spéciaux pour les numéros de page , les dates et autres contenus dynamiques sur toutes les pages. Le code suivant illustre l'ajout d'en-têtes Professional à vos documents générés. Le guide des en-têtes HTML présente les options de mise en forme avancées. Pour les en-têtes contenant uniquement du texte , utilisez les méthodes API plus simples.
Pour les configurations d'en-tête/pied de page avancées avec contenu dynamique :
// Create dynamic headers with metadata
var headerHtml = $@"
<div style='display: flex; justify-content: space-between; font-size: 10px;'>
<span>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</span>
<span>Environment: {Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}</span>
</div>";
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
HtmlFragment = headerHtml,
MaxHeight = 30,
DrawDividerLine = true
};' Create dynamic headers with metadata
Dim headerHtml = $"
<div style='display: flex; justify-content: space-between; font-size: 10px;'>
<span>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</span>
<span>Environment: {Environment.GetEnvironmentVariable(""ASPNETCORE_ENVIRONMENT"")}</span>
</div>"
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
.HtmlFragment = headerHtml,
.MaxHeight = 30,
.DrawDividerLine = True
}Le guide des en-têtes sur des pages spécifiques illustre l'application conditionnelle des en-têtes et pieds de page.
Les documents PDF Professional nécessitent souvent des en-têtes et des pieds de page sur chaque page, ainsi que des filigranes pour les documents brouillons ou confidentiels. IronPDF gère les deux au travers des propriétés sur l'objet RenderingOptions et la méthode ApplyWatermark sur le résultat PdfDocument :
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
MaxHeight = 25,
HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
MaxHeight = 20,
HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
};
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>",
30, VerticalAlignment.Middle, HorizontalAlignment.Center);
pdf.SaveAs("report-with-watermark.pdf");Imports IronPdf
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
.MaxHeight = 25,
.HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
.MaxHeight = 20,
.HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
}
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center)
pdf.SaveAs("report-with-watermark.pdf")
Les espaces réservés {page} et {total-pages} dans le HTML du pied de page sont automatiquement remplacés lors du rendu, de sorte que vous obtenez des numéros de page corrects sans post-traitement. Vous pouvez également ajouter des numéros de page , des images de fond ou des superpositions de premier plan , ainsi que des tampons de texte ou d'image personnalisés .
Pour vous assurer que votre sortie PDF est conforme à vos attentes, utilisez les règles CSS @media print et le paramètre PdfCssMediaType.Print. IronPDF prend entièrement en charge le contrôle des sauts de page et les formats de papier personnalisés :
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
string html = @"
<style>
@media print {
.no-print { display: none; }
body { font-size: 12pt; }
.page-break { page-break-after: always; }
}
@page {
size: A4;
margin: 1cm;
}
</style>
<div class='content'>
<h1>Professional Report</h1>
<div class='page-break'></div>
<h2>Section 2</h2>
</div>";
var pdf = renderer.RenderHtmlAsPdf(html);Imports IronPdf
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.ViewPortWidth = 1024
renderer.RenderingOptions.MarginTop = 10
renderer.RenderingOptions.MarginBottom = 10
renderer.RenderingOptions.MarginLeft = 10
renderer.RenderingOptions.MarginRight = 10
Dim html As String = "
<style>
@media print {
.no-print { display: none; }
body { font-size: 12pt; }
.page-break { page-break-after: always; }
}
@page {
size: A4;
margin: 1cm;
}
</style>
<div class='content'>
<h1>Professional Report</h1>
<div class='page-break'></div>
<h2>Section 2</h2>
</div>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
L'utilisation de CSS d'impression garantit que vos documents PDF conservent une mise en forme professionnelle tout en masquant les éléments web inutiles tels que les menus de navigation ou les boutons interactifs. Définir CssMediaType = PdfCssMediaType.Print indique au moteur de rendu d'appliquer vos règles @media print plutôt que les styles écran, ce qui supprime généralement les décorations de fond et ajuste la typographie pour la sortie imprimée. Vous pouvez également configurer des marges personnalisées par page et contrôler l'orientation et la rotation des pages pour les rapports grand format ou pivotés.
La spécification W3C CSS Paged Media définit comment les propriétés comme @page, page-break-before, et widows doivent se comporter dans une sortie paginée. Le moteur Chrome d'IronPDF suit de près cette spécification, de sorte que les styles écrits selon la norme CSS se traduisent fidèlement dans le PDF sans ajustements manuels.
Pour la conversion de pages ASPX héritées ou de documents qui dépendent de JavaScript pour remplir le contenu lors de l'exécution, IronPDF gère le processus de rendu de manière fiable. Vous pouvez configurer un délai de rendu pour laisser le temps à JavaScript de terminer son exécution avant que la page ne soit capturée :
public IActionResult ConvertDynamicContent()
{
var renderer = new ChromePdfRenderer();
// Enable JavaScript so dynamic content renders correctly
renderer.RenderingOptions.EnableJavaScript = true;
// Wait 1 second after page load for JavaScript to complete
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
// Generate your dynamic HTML string
string dynamicHtml = GenerateDynamicHtml();
var pdf = renderer.RenderHtmlAsPdf(dynamicHtml);
return File(pdf.BinaryData, "application/pdf", "dynamic.pdf");
}Imports IronPdf
Public Function ConvertDynamicContent() As IActionResult
Dim renderer As New ChromePdfRenderer()
' Enable JavaScript so dynamic content renders correctly
renderer.RenderingOptions.EnableJavaScript = True
' Wait 1 second after page load for JavaScript to complete
renderer.RenderingOptions.WaitFor.RenderDelay(1000)
' Generate your dynamic HTML string
Dim dynamicHtml As String = GenerateDynamicHtml()
Dim pdf = renderer.RenderHtmlAsPdf(dynamicHtml)
Return File(pdf.BinaryData, "application/pdf", "dynamic.pdf")
End Function
Un problème courant lors de la conversion HTML vers PDF est la présence de sauts de page indésirables qui séparent les titres de leur contenu ou coupent les lignes des tableaux en plein milieu. IronPDF résout cela grâce à un contrôle des sauts de page configurable en utilisant les règles page-break-before et page-break-inside CSS standard ainsi que l'API WaitFor d'IronPDF. La bibliothèque prend également en charge la génération asynchrone de PDF pour un débit amélioré dans les scénarios de trafic élevé.
Pour les applications JavaScript avancées, telles que les graphiques rendus par D3.js ou les composants React, vous pouvez injecter et exécuter du JavaScript personnalisé avant la prise de l'instantané de rendu, garantissant ainsi que le graphique ou le composant est entièrement monté avant la génération du PDF.
Le déploiement IronPDF dans des environnements conteneurisés nécessite des considérations spécifiques pour garantir des performances et une fiabilité optimales. Voici un exemple de Dockerfile prêt pour la production :
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443
# Install IronPDF Linux dependencies
RUN apt-get update && apt-get install -y \
libgdiplus \
libx11-6 \
libxcomposite1 \
libxdamage1 \
libxext6 \
libxfixes3 \
libxrandr2 \
libxrender1 \
libxtst6 \
fonts-liberation \
libnss3 \
libatk-bridge2.0-0 \
libdrm2 \
libxkbcommon0 \
libgbm1 \
libasound2 \
&& apt-get clean \
&& rm -rf /var/lib/apt/lists/*
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["YourProject.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build
FROM build AS publish
RUN dotnet publish -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
# Set IronPDF temp folder for container environment
ENV IRONPDF_TEMP_FOLDER=/tmp/ironpdf
ENTRYPOINT ["dotnet", "YourProject.dll"]Le guide d'intégration Docker fournit des instructions de déploiement complètes. Pour des conteneurs de taille minimale , utilisez des builds multi-étapes. Le guide de déploiement Linux couvre les dépendances spécifiques à la plateforme.
Pour les déploiements Kubernetes, configurez les limites de ressources appropriées :
apiVersion: apps/v1
kind: Deployment
metadata:
name: pdf-service
spec:
replicas: 3
template:
spec:
containers:
- name: pdf-generator
image: your-registry/pdf-service:latest
resources:
requests:
memory: "512Mi"
cpu: "500m"
limits:
memory: "2Gi"
cpu: "2000m"
env:
- name: IRONPDF_LICENSE_KEY
valueFrom:
secretKeyRef:
name: ironpdf-license
key: key
livenessProbe:
httpGet:
path: /health
port: 80
initialDelaySeconds: 30
periodSeconds: 10Le guide des dossiers d'exécution explique la gestion des dépendances dans les conteneurs. Pour Red Hat Enterprise Linux , une configuration supplémentaire peut être nécessaire.
Pour garantir des performances et une qualité optimales lors de la conversion de HTML en PDF, suivez ces pratiques éprouvées. Envisagez la mise en œuvre d'un traitement asynchrone pour une meilleure utilisation des ressources dans les scénarios de trafic élevé. Le guide sur le traitement parallèle présente des techniques de génération de PDF simultanées.
Testez toujours votre rendu HTML dans un navigateur avant de générer des PDF afin de vérifier le style et la mise en page. Utilisez autant que possible des URL absolues pour les ressources externes, car les chemins relatifs peuvent poser problème lors de la conversion. Pour les pages complexes utilisant beaucoup de JavaScript , ajoutez des délais de rendu pour garantir un chargement complet. Envisagez la mise en place d'un système de cache pour les documents fréquemment générés afin de réduire la charge du serveur. Pour plus de bonnes pratiques ASP.NET Core , consultez la documentation officielle de Microsoft. Le guide de rendu au pixel près garantit une qualité de sortie optimale.
Lors du déploiement en production, configurez les chemins d'accès aux dossiers temporaires appropriés et assurez-vous que votre environnement d'hébergement dispose des dépendances nécessaires installées, en particulier pour les déploiements Linux . Évitez de placer le script et la logique de conversion dans le même répertoire afin d'éviter les conflits. Consultez notre guide de dépannage pour les scénarios de déploiement courants. Validez toujours que l'entrée n'est pas une URL lorsque vous avez l'intention de traiter le contenu HTML direct pour éviter un comportement inattendu. Le guide initial d'optimisation du rendu aborde les problèmes de performance les plus courants.
Pour les scénarios à hautes performances, mettez en œuvre la mise en commun des connexions et la gestion des ressources :
public class PdfGeneratorService : IDisposable
{
private readonly SemaphoreSlim _semaphore;
private readonly ILogger<PdfGeneratorService> _logger;
public PdfGeneratorService(ILogger<PdfGeneratorService> logger)
{
_logger = logger;
// Limit concurrent PDF generations
_semaphore = new SemaphoreSlim(Environment.ProcessorCount * 2);
}
public async Task<byte[]> GeneratePdfAsync(string html)
{
await _semaphore.WaitAsync();
try
{
using (var renderer = new ChromePdfRenderer())
{
var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));
return pdf.BinaryData;
}
}
finally
{
_semaphore.Release();
}
}
public void Dispose()
{
_semaphore?.Dispose();
}
}Public Class PdfGeneratorService
Implements IDisposable
Private ReadOnly _semaphore As SemaphoreSlim
Private ReadOnly _logger As ILogger(Of PdfGeneratorService)
Public Sub New(logger As ILogger(Of PdfGeneratorService))
_logger = logger
' Limit concurrent PDF generations
_semaphore = New SemaphoreSlim(Environment.ProcessorCount * 2)
End Sub
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
Await _semaphore.WaitAsync()
Try
Using renderer = New ChromePdfRenderer()
Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(html))
Return pdf.BinaryData
End Using
Finally
_semaphore.Release()
End Try
End Function
Public Sub Dispose() Implements IDisposable.Dispose
_semaphore?.Dispose()
End Sub
End ClassLe guide sur le multithreading propose des modèles de concurrence avancés. Pour prévenir les fuites de mémoire , mettez en œuvre des modèles de suppression appropriés.
Surveillez les indicateurs de performance à l'aide d'une journalisation personnalisée :
// Configure logging for production monitoring
Installation.LoggingMode = IronPdf.Logging.LoggingModes.Custom;
Installation.CustomLogger = (level, message) =>
{
_logger.Log(
level == IronPdf.Logging.LogLevels.Error ? LogLevel.Error : LogLevel.Information,
"IronPDF: {Message}",
message
);
};' Configure logging for production monitoring
Installation.LoggingMode = IronPdf.Logging.LoggingModes.Custom
Installation.CustomLogger = Sub(level, message)
_logger.Log(
If(level = IronPdf.Logging.LogLevels.Error, LogLevel.Error, LogLevel.Information),
"IronPDF: {Message}",
message
)
End SubLe guide sur les fichiers journaux Azure et la gestion des journaux AWS expliquent les stratégies de journalisation spécifiques au cloud. Mettre en œuvre une intégration du support technique pour une résolution rapide des problèmes.
Pour une sécurité renforcée, mettez en œuvre le chiffrement PDF et les signatures numériques . Le guide de sécurité CVE aborde les problèmes de sécurité courants. Envisagez la désinfection des fichiers PDF pour le contenu téléchargé par les utilisateurs.
La conversion de HTML en PDF dans les applications ASP.NET Core devient simple avec IronPDF. Le rendu basé sur Chrome de la bibliothèque garantit une conversion précise tout en offrant de nombreuses options de personnalisation pour la génération de documents Professional .
Que vous travailliez avec des chaînes HTML, des URL ou des pages Web complètes, IronPDF préserve la mise en forme exacte, le style CSS et le comportement JavaScript . Cet outil basé sur .NET gère efficacement l'ensemble du processus de conversion. La prise en charge de Docker et les fonctionnalités d'optimisation des performances de cette bibliothèque la rendent idéale pour les déploiements conteneurisés modernes et les architectures de microservices.
Commencez votre essai gratuit de 30 jours ou réservez une démo avec notre équipe.
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
