1. IronPDF
  2. Guides pratiques
  3. URL de base et encodage des ressources
Comment utiliser les URLs de base dans la génération de PDFs avec C#

How to Use Base URLs & Asset Encoding in C# .NET 10

Curtis Chau
Curtis Chau
Mis à jour:
This article was translated from English: Does it need improvement?
Translated
View the article in English

Les URL de base dans IronPDF permettent de charger correctement les ressources CSS, JavaScript et les images lors de la conversion HTML vers PDF en spécifiant le paramètre BaseUrlOrPath, qui peut être une URL Web ou un chemin d'accès local pour la résolution relative des ressources.

Démarrage rapide : Implémenter les URL de base dans IronPDF

Commencez par utiliser IronPDF en mettant en œuvre des URL de base pour un chargement transparent des ressources lors de la conversion de HTML en PDF en .NET C#. Cet exemple montre comment configurer BaseUrlOrPath pour s'assurer que tous les fichiers CSS, JavaScript et images sont correctement référencés, ce qui simplifie la génération de PDF avec une configuration minimale.

  1. Installez IronPDF avec le Gestionnaire de Packages NuGet

    PM > Install-Package IronPdf

  2. Copiez et exécutez cet extrait de code.

    new IronPdf.ChromePdfRenderer().RenderHtmlAsPdf("<img src='icons/logo.png'>", @"C:\site\assets\").SaveAs("with-assets.pdf");

  3. Déployez pour tester sur votre environnement de production.

    Commencez à utiliser IronPDF dans votre projet dès aujourd'hui avec un essai gratuit

    arrow pointer

Flux de travail minimal (5 étapes)

  1. Télécharger IronPDF pour la prise en charge de HTML à CSS à image
  2. Spécifiez le paramètre BaseUrlOrPath pour les images externes dans HTML
  3. Configurez correctement src dans MVC pour l'affichage web et PDF
  4. Spécifiez des en-têtes et pieds de page personnalisés en utilisant la propriété BaseUrl
  5. Vérifiez le fichier PDF de sortie

Convert.ToBase64String


Comment rendre des PDF à partir de chaînes HTML avec des images et des éléments CSS ?

Lors de la conversion de chaînes HTML en PDF/A, définissez un paramètre BaseUrlOrPath pour les ressources telles que les fichiers CSS, JavaScript et les images. Le BaseUrlOrPath spécifie l'URL de base par rapport à laquelle tous les ressources sont chargées. CustomCssUrl

Il peut s'agir d'une URL commençant par "http" pour charger des ressources à distance ou d'un chemin d'accès à un fichier local pour accéder à des ressources sur disque. La configuration correcte de BaseUrlOrPath garantit le chargement correct des ressources lors de la conversion. Pour plus de détails sur la conversion HTML en PDF, consultez notre tutoriel complet HTML en PDF.

:path=/static-assets/pdf/content-code-examples/how-to/base-urls-baseurl.cs
using IronPdf;

// Instantiate ChromePdfRenderer
ChromePdfRenderer renderer = new ChromePdfRenderer();

string baseUrl = @"C:\site\assets\";
string html = "<img src='icons/iron.png'>";

// Render HTML to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf(html, baseUrl);

// Export PDF
pdf.SaveAs("html-with-assets.pdf");
Imports IronPdf

' Instantiate ChromePdfRenderer
Private renderer As New ChromePdfRenderer()

Private baseUrl As String = "C:\site\assets\"
Private html As String = "<img src='icons/iron.png'>"

' Render HTML to PDF
Private pdf As PdfDocument = renderer.RenderHtmlAsPdf(html, baseUrl)

' Export PDF
pdf.SaveAs("html-with-assets.pdf")
$vbLabelText   $csharpLabel

Pour les scénarios complexes impliquant des ressources externes, explorez notre guide sur la gestion des polices ou l'ajout d'images aux PDF.

Comment configurer les URL de base dans les applications MVC?

Dans les applications MVC, la spécification des chemins d'accès aux fichiers images nécessite une configuration minutieuse. Pour vous assurer qu'IronPDF trouve les images et les affiche correctement sur le site web, configurez correctement les attributs baseUrl et HTML src="".

Avec la hiérarchie de fichiers indiquée ci-dessous

  • baseUrlOrPath vers @"wwwroot/image"
  • src attribut vers " ../image/Sample.jpg "
wwwroot
└── image
    ├── Sample.jpg
    └── Sample.png

Par exemple :

:path=/static-assets/pdf/content-code-examples/how-to/base-mvc.cs
// Instantiate ChromePdfRenderer
ChromePdfRenderer renderer = new ChromePdfRenderer();

// Render HTML to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf("html.Result", @"wwwroot/image");
' Instantiate ChromePdfRenderer
Dim renderer As New ChromePdfRenderer()

' Render HTML to PDF
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("html.Result", "wwwroot/image")
$vbLabelText   $csharpLabel 

<img src="../image/Sample.jpg"/>
<img src="../image/Sample.png"/>

<img src="../image/Sample.jpg"/>
<img src="../image/Sample.png"/>
HTML

Pour les mises en œuvre spécifiques à ASP.NET Core MVC, consultez notre guide CSHTML to PDF (MVC Core).

Quels sont les formats de chemin de fichier à éviter ?

Avertissement

Formats de chemin de fichier qui ne fonctionnent pas

Ces formats fonctionnent dans le navigateur Chrome mais pointent vers des répertoires erronés dans les applications MVC. Ils fonctionnent avec IronPDF si baseUrlOrPath est fourni dans la méthode RenderHtmlAsPdf :

<img src="image/footer.png"/>  
<img src="./image/footer.png"/>  
<img src="image/footer.png"/>  
<img src="./image/footer.png"/>
HTML

Ces formats fonctionnent avec les applications MVC mais échouent avec les chemins de fichiers IronPDF :

<img src="/image/footer.png"/>  
<img src="~/image/footer.png"/>
<img src="/image/footer.png"/>  
<img src="~/image/footer.png"/>
HTML

)}]

Quels sont les conseils de dépannage courants pour le chargement d'actifs ?

Lorsque les ressources ne se chargent pas, suivez ces étapes de dépannage :

  1. Vérifiez les chemins absolus : Utilisez des chemins de fichiers absolus pendant le développement pour confirmer l'accessibilité
  2. Vérifiez les permissions de fichier : Assurez-vous que l'application a accès en lecture aux répertoires d'actifs
  3. Testez avec des URL distantes : Utilisez des URL pleinement qualifiées pour isoler les problèmes de chemin
  4. Activer la journalisation : Utilisez la journalisation custom logging d'IronPDF pour déboguer le chargement des actifs
// Example: Debug asset loading with absolute paths
ChromePdfRenderer renderer = new ChromePdfRenderer();

// Enable debug logging
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(500); // Give assets time to load

// Use absolute path for testing
string absoluteBasePath = Path.GetFullPath(@"C:\MyProject\wwwroot\assets");
string html = @"
    <html>
    <head>
        <link rel='stylesheet' href='styles/main.css'>
    </head>
    <body>
        <img src='images/logo.png' />
        <script src='scripts/app.js'></script>
    </body>
    </html>";

PdfDocument pdf = renderer.RenderHtmlAsPdf(html, absoluteBasePath);
// Example: Debug asset loading with absolute paths
ChromePdfRenderer renderer = new ChromePdfRenderer();

// Enable debug logging
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(500); // Give assets time to load

// Use absolute path for testing
string absoluteBasePath = Path.GetFullPath(@"C:\MyProject\wwwroot\assets");
string html = @"
    <html>
    <head>
        <link rel='stylesheet' href='styles/main.css'>
    </head>
    <body>
        <img src='images/logo.png' />
        <script src='scripts/app.js'></script>
    </body>
    </html>";

PdfDocument pdf = renderer.RenderHtmlAsPdf(html, absoluteBasePath);
Imports System.IO

' Example: Debug asset loading with absolute paths
Dim renderer As New ChromePdfRenderer()

' Enable debug logging
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(500) ' Give assets time to load

' Use absolute path for testing
Dim absoluteBasePath As String = Path.GetFullPath("C:\MyProject\wwwroot\assets")
Dim html As String = "
    <html>
    <head>
        <link rel='stylesheet' href='styles/main.css'>
    </head>
    <body>
        <img src='images/logo.png' />
        <script src='scripts/app.js'></script>
    </body>
    </html>"

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html, absoluteBasePath)
$vbLabelText   $csharpLabel

Comment ajouter des en-têtes et des pieds de page HTML avec des images?

Lors du rendu des en-têtes et pieds de page HTML dans des PDF nouveaux ou existants, ceux-ci sont traités comme des documents HTML autonomes et n'héritent pas du BaseURL du PDF. Pour des options complètes d'en-tête et de pied de page, consultez notre guide des en-têtes et pieds de page.

Définissez un BaseURL à partir duquel les ressources peuvent être chargées : ChromePdfRenderOptions

Pourquoi les en-têtes n'héritent-ils pas des URL de base du document principal ?

Les en-têtes et les pieds de page sont rendus sous forme de documents HTML distincts pour des raisons de performance et d'isolation. Cette conception permet :

  • Style indépendant sans affecter le contenu principal
  • Rendu cohérent sur toutes les pages
  • Mieux gérer la mémoire pour les documents volumineux
  • Souplesse d'utilisation de différentes sources d'actifs

Comment définir des URL de base différentes pour les en-têtes et le contenu ?

Spécifiez des URL de base différentes pour les en-têtes, les pieds de page et le contenu principal afin d'organiser les ressources de manière efficace :

ChromePdfRenderer renderer = new ChromePdfRenderer();

// Main content base URL
string contentBaseUrl = @"C:\website\public\";

// Header specific assets
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<img src='header-logo.png'><link rel='stylesheet' href='header.css'>",
    BaseUrl = new Uri(@"C:\website\headers\").AbsoluteUri
};

// Footer specific assets
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div class='footer'>© 2024 Company</div><link rel='stylesheet' href='footer.css'>",
    BaseUrl = new Uri(@"C:\website\footers\").AbsoluteUri
};

// Render main content with its own base URL
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Main Content</h1>", contentBaseUrl);
ChromePdfRenderer renderer = new ChromePdfRenderer();

// Main content base URL
string contentBaseUrl = @"C:\website\public\";

// Header specific assets
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    HtmlFragment = "<img src='header-logo.png'><link rel='stylesheet' href='header.css'>",
    BaseUrl = new Uri(@"C:\website\headers\").AbsoluteUri
};

// Footer specific assets
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
{
    HtmlFragment = "<div class='footer'>© 2024 Company</div><link rel='stylesheet' href='footer.css'>",
    BaseUrl = new Uri(@"C:\website\footers\").AbsoluteUri
};

// Render main content with its own base URL
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Main Content</h1>", contentBaseUrl);
Dim renderer As New ChromePdfRenderer()

' Main content base URL
Dim contentBaseUrl As String = "C:\website\public\"

' Header specific assets
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
    .HtmlFragment = "<img src='header-logo.png'><link rel='stylesheet' href='header.css'>",
    .BaseUrl = New Uri("C:\website\headers\").AbsoluteUri
}

' Footer specific assets
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div class='footer'>© 2024 Company</div><link rel='stylesheet' href='footer.css'>",
    .BaseUrl = New Uri("C:\website\footers\").AbsoluteUri
}

' Render main content with its own base URL
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Main Content</h1>", contentBaseUrl)
$vbLabelText   $csharpLabel

Comment convertir des fichiers HTML en PDF avec des ressources locales ?

Lors de la conversion de fichiers HTML en PDF, toutes les ressources sont supposées être locales à ce fichier. Pour en savoir plus sur la conversion de fichiers HTML, consultez notre guide Fichier HTML en PDF.

:path=/static-assets/pdf/content-code-examples/how-to/base-html-file.cs
using IronPdf;

// Instantiate ChromePdfRenderer
ChromePdfRenderer renderer = new ChromePdfRenderer();

// Render HTML file to PDF
PdfDocument pdf = renderer.RenderHtmlFileAsPdf("C:\\Assets\\TestInvoice1.html");

// Export PDF
pdf.SaveAs("Invoice.pdf");
Imports IronPdf

' Instantiate ChromePdfRenderer
Private renderer As New ChromePdfRenderer()

' Render HTML file to PDF
Private pdf As PdfDocument = renderer.RenderHtmlFileAsPdf("C:\Assets\TestInvoice1.html")

' Export PDF
pdf.SaveAs("Invoice.pdf")
$vbLabelText   $csharpLabel

Dans l'exemple ci-dessus, tous les fichiers JS, CSS et images se chargent à partir du dossier C:\Assets sur le disque - le même répertoire que le fichier HTML.

Pour plus de commodité, utilisez CustomCssUrl dans HtmlToPdf pour les feuilles de style supplémentaires afin de spécifier une feuille de style supplémentaire utilisée uniquement pour le rendu PDF .NET si vous le souhaitez. Par exemple :

:path=/static-assets/pdf/content-code-examples/how-to/base-html-file-baseurl.cs
using IronPdf;

// Instantiate ChromePdfRenderer
ChromePdfRenderer renderer = new ChromePdfRenderer();

// Set additional CSS url
renderer.RenderingOptions.CustomCssUrl = "./style.css";

// Render HTML file to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export PDF
pdf.SaveAs("tryCss.pdf");
Imports IronPdf

' Instantiate ChromePdfRenderer
Private renderer As New ChromePdfRenderer()

' Set additional CSS url
renderer.RenderingOptions.CustomCssUrl = "./style.css"

' Render HTML file to PDF
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>")

' Export PDF
pdf.SaveAs("tryCss.pdf")
$vbLabelText   $csharpLabel

CustomCssUrl

Veuillez noterLa propriété ChromePdfRenderOptions.CustomCssUrl ne fonctionne actuellement que lors de la conversion de chaînes HTML en PDF à l'aide de la méthode RenderHtmlAsPdf.)})]

Quand dois-je utiliser CustomCssUrl pour une mise en forme supplémentaire?

CustomCssUrl est idéal pour :

  • Styles spécifiques à l'impression : Masquer les menus de navigation ou les éléments interactifs
  • Optimisation de la mise en page PDF : Ajuster les marges et les sauts de page pour l'impression
  • Formatage conditionnel : Appliquer des styles uniquement lors de la génération de PDF
  • A/B testing : Testez différentes mises en page PDF sans modifier le code HTML source

Comment gérer les chemins d'accès relatifs dans les fichiers HTML?

Lorsque vous travaillez avec des fichiers HTML contenant des chemins d'accès relatifs, assurez-vous que votre structure de fichier prend en charge les références :

// Example HTML file structure
/*
C:\Projects\Reports\
    ├── invoice.html
    ├── css\
    │   └── styles.css
    ├── js\
    │   └── calculations.js
    └── images\
        └── logo.png
*/

// HTML content with relative paths
string htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <link rel='stylesheet' href='css/styles.css'>
    <script src='js/calculations.js'></script>
</head>
<body>
    <img src='images/logo.png' alt='Company Logo'>
    <h1>Invoice #12345</h1>
</body>
</html>";

// Save HTML and render
File.WriteAllText(@"C:\Projects\Reports\invoice.html", htmlContent);
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlFileAsPdf(@"C:\Projects\Reports\invoice.html");
pdf.SaveAs("invoice-output.pdf");
// Example HTML file structure
/*
C:\Projects\Reports\
    ├── invoice.html
    ├── css\
    │   └── styles.css
    ├── js\
    │   └── calculations.js
    └── images\
        └── logo.png
*/

// HTML content with relative paths
string htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <link rel='stylesheet' href='css/styles.css'>
    <script src='js/calculations.js'></script>
</head>
<body>
    <img src='images/logo.png' alt='Company Logo'>
    <h1>Invoice #12345</h1>
</body>
</html>";

// Save HTML and render
File.WriteAllText(@"C:\Projects\Reports\invoice.html", htmlContent);
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlFileAsPdf(@"C:\Projects\Reports\invoice.html");
pdf.SaveAs("invoice-output.pdf");
Imports System.IO
Imports IronPdf

' Example HTML file structure
'
' C:\Projects\Reports\
'     ├── invoice.html
'     ├── css\
'     │   └── styles.css
'     ├── js\
'     │   └── calculations.js
'     └── images\
'         └── logo.png
'

' HTML content with relative paths
Dim htmlContent As String = "
<!DOCTYPE html>
<html>
<head>
    <link rel='stylesheet' href='css/styles.css'>
    <script src='js/calculations.js'></script>
</head>
<body>
    <img src='images/logo.png' alt='Company Logo'>
    <h1>Invoice #12345</h1>
</body>
</html>"

' Save HTML and render
File.WriteAllText("C:\Projects\Reports\invoice.html", htmlContent)
Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlFileAsPdf("C:\Projects\Reports\invoice.html")
pdf.SaveAs("invoice-output.pdf")
$vbLabelText   $csharpLabel

Comment coder des images directement en HTML à l'aide de Base64?

Les images peuvent être encodées directement dans des fichiers HTML ou des chaînes de caractères, ce qui permet d'éviter les problèmes liés aux images manquantes. Utilisez l'encodage base64 pour cette approche. Utilisez l'encodage base64 pour cette approche. Utilisez l'encodage base64 pour cette approche :

  1. Obtenez d'abord les données binaires de l'image en lisant le fichier ou en les recevant par une demande réseau.
  2. Utilisez la méthode Convert.ToBase64String dans Microsoft .NET pour convertir des données binaires en base64.
  3. Construisez la balise image en HTML en utilisant "data:image/svg+xml;base64," avant les données en base64. Notez que le type d'image est spécifié avant les données base64. Visitez la MDN Web Docs on Image Types and Formats pour plus d'informations sur les types et formats d'images.
:path=/static-assets/pdf/content-code-examples/how-to/add-images-to-pdfs-base64-image.cs
using IronPdf;
using System;
using System.IO;

ChromePdfRenderer renderer = new ChromePdfRenderer();

// Import image file binary data
byte[] binaryData = File.ReadAllBytes("ironpdf-logo-text-dotnet.svg");

// Convert the binary data to base 64
string imgDataUri = Convert.ToBase64String(binaryData);

// Embed in HTML
string html = $"<img src='data:image/svg+xml;base64,{imgDataUri}'>";

// Convert HTML to PDF
PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

// Export the PDF
pdf.SaveAs("embedImageBase64.pdf");
Imports IronPdf
Imports System
Imports System.IO

Private renderer As New ChromePdfRenderer()

' Import image file binary data
Private binaryData() As Byte = File.ReadAllBytes("ironpdf-logo-text-dotnet.svg")

' Convert the binary data to base 64
Private imgDataUri As String = Convert.ToBase64String(binaryData)

' Embed in HTML
Private html As String = $"<img src='data:image/svg+xml;base64,{imgDataUri}'>"

' Convert HTML to PDF
Private pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)

' Export the PDF
pdf.SaveAs("embedImageBase64.pdf")
$vbLabelText   $csharpLabel

Pourquoi choisir l'encodage Base64 plutôt que les références de fichiers?

L'encodage Base64 offre plusieurs avantages :

  • HTML autonome : Aucune dépendance externe, simplifiant la distribution
  • Compatibilité multiplateforme : Fonctionne indépendamment des différences de système de fichiers
  • Sécurité : Aucun accès au système de fichiers requis, réduisant les risques de sécurité
  • Fiabilité : Élimine les erreurs liées aux actifs manquants en production
  • Contrôle des versions : Les images font partie du HTML, simplifiant la gestion des versions

Il convient toutefois de prendre en compte les compromis suivants :

  • Taille HTML accrue : L'encodage Base64 augmente la taille d'environ 33 %
  • Pas de mise en cache : Les images intégrées ne peuvent pas être mises en cache séparément
  • Utilisation de la mémoire : L'image entière doit être chargée en mémoire

Quels sont les formats d'image qui fonctionnent le mieux avec le codage Base64 ?

Les différents formats d'images ont une efficacité variable lorsqu'ils sont encodés en base64 :

// Example: Encoding different image formats
public string EncodeImageWithMimeType(string imagePath)
{
    byte[] imageBytes = File.ReadAllBytes(imagePath);
    string base64 = Convert.ToBase64String(imageBytes);

    // Determine MIME type based on extension
    string extension = Path.GetExtension(imagePath).ToLower();
    string mimeType = extension switch
    {
        ".png" => "image/png",      // Best for graphics with transparency
        ".jpg" or ".jpeg" => "image/jpeg",  // Best for photographs
        ".gif" => "image/gif",       // Best for simple animations
        ".svg" => "image/svg+xml",   // Best for scalable graphics
        ".webp" => "image/webp",     // Best overall compression
        _ => "image/png"             // Default fallback
    };

    return $"data:{mimeType};base64,{base64}";
}

// Usage
string encodedImage = EncodeImageWithMimeType("logo.png");
string html = $"<img src='{encodedImage}' alt='Company Logo'>";
// Example: Encoding different image formats
public string EncodeImageWithMimeType(string imagePath)
{
    byte[] imageBytes = File.ReadAllBytes(imagePath);
    string base64 = Convert.ToBase64String(imageBytes);

    // Determine MIME type based on extension
    string extension = Path.GetExtension(imagePath).ToLower();
    string mimeType = extension switch
    {
        ".png" => "image/png",      // Best for graphics with transparency
        ".jpg" or ".jpeg" => "image/jpeg",  // Best for photographs
        ".gif" => "image/gif",       // Best for simple animations
        ".svg" => "image/svg+xml",   // Best for scalable graphics
        ".webp" => "image/webp",     // Best overall compression
        _ => "image/png"             // Default fallback
    };

    return $"data:{mimeType};base64,{base64}";
}

// Usage
string encodedImage = EncodeImageWithMimeType("logo.png");
string html = $"<img src='{encodedImage}' alt='Company Logo'>";
Imports System.IO

Public Function EncodeImageWithMimeType(imagePath As String) As String
    Dim imageBytes As Byte() = File.ReadAllBytes(imagePath)
    Dim base64 As String = Convert.ToBase64String(imageBytes)

    ' Determine MIME type based on extension
    Dim extension As String = Path.GetExtension(imagePath).ToLower()
    Dim mimeType As String = extension.ToLower() Select Case extension
        Case ".png"
            mimeType = "image/png" ' Best for graphics with transparency
        Case ".jpg", ".jpeg"
            mimeType = "image/jpeg" ' Best for photographs
        Case ".gif"
            mimeType = "image/gif" ' Best for simple animations
        Case ".svg"
            mimeType = "image/svg+xml" ' Best for scalable graphics
        Case ".webp"
            mimeType = "image/webp" ' Best overall compression
        Case Else
            mimeType = "image/png" ' Default fallback
    End Select

    Return $"data:{mimeType};base64,{base64}"
End Function

' Usage
Dim encodedImage As String = EncodeImageWithMimeType("logo.png")
Dim html As String = $"<img src='{encodedImage}' alt='Company Logo'>"
$vbLabelText   $csharpLabel

Quel est l'impact de l'encodage Base64 sur la taille des fichiers PDF?

L'encodage Base64 affecte la taille des PDF de manière prévisible :

// Comparison example
public void CompareFileSizes()
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();

    // Method 1: External image reference
    string htmlExternal = "<img src='large-photo.jpg'>";
    PdfDocument pdfExternal = renderer.RenderHtmlAsPdf(htmlExternal, @"C:\images\");

    // Method 2: Base64 encoded image
    byte[] imageBytes = File.ReadAllBytes(@"C:\images\large-photo.jpg");
    string base64Image = Convert.ToBase64String(imageBytes);
    string htmlBase64 = $"<img src='data:image/jpeg;base64,{base64Image}'>";
    PdfDocument pdfBase64 = renderer.RenderHtmlAsPdf(htmlBase64);

    // Compare sizes
    Console.WriteLine($"Original image: {imageBytes.Length / 1024} KB");
    Console.WriteLine($"PDF with external image: {pdfExternal.BinaryData.Length / 1024} KB");
    Console.WriteLine($"PDF with base64 image: {pdfBase64.BinaryData.Length / 1024} KB");
}
// Comparison example
public void CompareFileSizes()
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();

    // Method 1: External image reference
    string htmlExternal = "<img src='large-photo.jpg'>";
    PdfDocument pdfExternal = renderer.RenderHtmlAsPdf(htmlExternal, @"C:\images\");

    // Method 2: Base64 encoded image
    byte[] imageBytes = File.ReadAllBytes(@"C:\images\large-photo.jpg");
    string base64Image = Convert.ToBase64String(imageBytes);
    string htmlBase64 = $"<img src='data:image/jpeg;base64,{base64Image}'>";
    PdfDocument pdfBase64 = renderer.RenderHtmlAsPdf(htmlBase64);

    // Compare sizes
    Console.WriteLine($"Original image: {imageBytes.Length / 1024} KB");
    Console.WriteLine($"PDF with external image: {pdfExternal.BinaryData.Length / 1024} KB");
    Console.WriteLine($"PDF with base64 image: {pdfBase64.BinaryData.Length / 1024} KB");
}
' Comparison example
Public Sub CompareFileSizes()
    Dim renderer As New ChromePdfRenderer()

    ' Method 1: External image reference
    Dim htmlExternal As String = "<img src='large-photo.jpg'>"
    Dim pdfExternal As PdfDocument = renderer.RenderHtmlAsPdf(htmlExternal, "C:\images\")

    ' Method 2: Base64 encoded image
    Dim imageBytes As Byte() = File.ReadAllBytes("C:\images\large-photo.jpg")
    Dim base64Image As String = Convert.ToBase64String(imageBytes)
    Dim htmlBase64 As String = $"<img src='data:image/jpeg;base64,{base64Image}'>"
    Dim pdfBase64 As PdfDocument = renderer.RenderHtmlAsPdf(htmlBase64)

    ' Compare sizes
    Console.WriteLine($"Original image: {imageBytes.Length \ 1024} KB")
    Console.WriteLine($"PDF with external image: {pdfExternal.BinaryData.Length \ 1024} KB")
    Console.WriteLine($"PDF with base64 image: {pdfBase64.BinaryData.Length \ 1024} KB")
End Sub
$vbLabelText   $csharpLabel

Pour des résultats optimaux :

  • Utilisez base64 pour les petites icônes et logos (< 50KB)
  • Utilisez des références externes pour les grandes images et photographies
  • Envisagez la compression avant l'encodage
  • Utilisez des formats d'image appropriés pour le type de contenu

Pour des techniques avancées d'optimisation des PDF, explorez notre guide de compression des PDF.

Questions Fréquemment Posées

Comment puis-je m'assurer que les éléments CSS et JavaScript se chargent correctement lors de la conversion de HTML en PDF ?

IronPDF vous permet de spécifier un paramètre BaseUrlOrPath lors de la conversion de HTML en PDF. Ce paramètre peut être une URL web ou un chemin d'accès à un fichier local qui sert de référence de base pour tous les chemins d'accès relatifs dans votre HTML, garantissant ainsi que les CSS, JavaScript et images se chargent correctement.

À quoi sert le paramètre BaseUrlOrPath ?

Le paramètre BaseUrlOrPath d'IronPDF spécifie l'URL de base à partir de laquelle tous les actifs (CSS, JavaScript, images) se chargent relativement lors de la conversion de HTML en PDF. Il peut s'agir d'une URL commençant par "http" pour les ressources distantes ou d'un chemin d'accès à un fichier local pour les ressources sur disque.

Comment puis-je rendre un PDF avec des actifs en une seule ligne de code ?

Vous pouvez utiliser IronPDF's ChromePdfRenderer pour rendre HTML avec des actifs en une seule ligne : `new IronPdf.ChromePdfRenderer().RenderHtmlAsPdf("", @"C:\site\assets\").SaveAs("with-assets.pdf");`. Cela permet de définir le BaseUrlOrPath afin de s'assurer que toutes les ressources sont correctement chargées.

Comment configurer les chemins d'accès aux images dans les applications MVC pour la génération de PDF ?

Dans les applications MVC using IronPDF, définissez baseUrlOrPath sur votre sous-répertoire wwwroot (par exemple, @"wwwroot/image") et configurez l'attribut HTML src avec le chemin relatif (par exemple, "../image/Sample.jpg"). Cela garantit que les images s'affichent correctement à la fois sur le site web et dans le PDF généré.

Puis-je utiliser des ressources locales et distantes lors de la conversion de HTML en PDF ?

Oui, IronPDF prend en charge les ressources locales et distantes. Pour les ressources distantes, définissez BaseUrlOrPath comme une URL web commençant par 'http'. Pour les ressources locales, utilisez un chemin de fichier sur votre disque. Cette flexibilité vous permet de faire référence à des ressources provenant de différentes sources lors de la génération du PDF.

Que se passe-t-il si je ne définis pas le paramètre BaseUrlOrPath ?

Si le paramètre BaseUrlOrPath n'est pas défini dans IronPDF, les chemins d'accès relatifs aux ressources dans votre HTML ne seront pas résolus correctement, ce qui entraînera l'absence de styles CSS, de fonctionnalités JavaScript et d'images dans le PDF généré. Spécifiez toujours ce paramètre lorsque votre HTML contient des références relatives.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

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 ...

Lire la suite
Prêt à commencer?
Nuget Téléchargements 19,014,616 | Version : 2026.5 just released
Still Scrolling Icon

Vous faites encore défiler ?

Vous voulez une preuve rapidement ? PM > Install-Package IronPdf
exécuter un échantillon Regardez votre code HTML se transformer en PDF.