Rendre des pages PDF dans PictureBox de Windows Forms | Guide C#

Pourquoi PictureBox ne peut-elle pas afficher directement des fichiers PDF?

Le contrôle PictureBox dans Windows Forms est conçu exclusivement pour les formats d'image : BMP, PNG, JPG, GIF, TIFF et quelques autres. Lorsque vous tentez d'attribuer un chemin d'accès à un fichier PDF à PictureBox.ImageLocation ou de charger un flux PDF dans PictureBox.Image, le contrôle génère une exception car le format binaire PDF n'est pas un format d'image reconnu.

Certaines solutions tentent de contourner ce problème en intégrant Adobe Acrobat via l'interopérabilité COM. Cela crée une forte dépendance à l'égard d'Adobe Reader, qui doit être installé sur chaque machine exécutant l'application — une contrainte de déploiement difficile à gérer en environnement Enterprise . Il verrouille également le moteur de rendu à la version d'Acrobat installée sur l'utilisateur, ce qui peut entraîner des problèmes de compatibilité entre différentes machines.

Une approche plus propre consiste à utiliser une bibliothèque PDF .NET qui convertit les pages PDF en images bitmap à l'exécution. IronPDF offre précisément cette fonctionnalité grâce à sa méthode ToBitmap, qui convertit chaque page d'un document PDF en un objet AnyBitmap. Vous pouvez ensuite convertir cet objet en un objet standard System.Drawing.Bitmap et l'affecter directement à PictureBox.Image. Aucune installation d'Adobe requise, aucun enregistrement COM et aucun visualiseur externe intégré à votre fenêtre d'application.

Cette technique fonctionne avec .NET Framework 4.6.2 et versions ultérieures, ainsi qu'avec .NET 6, 8 et 10 sous Windows. Le moteur de rendu d' IronPDF est basé sur Chrome, ce qui signifie qu'il produit un rendu haute fidélité même pour les PDF avec des mises en page complexes, des polices intégrées et un contenu mixte image/texte.

Comment installer IronPDF pour un projet Windows Forms ?

Avant d'écrire la moindre ligne de code, vous devez ajouter IronPDF à votre projet. La méthode la plus rapide consiste à utiliser l'interface de ligne de commande du gestionnaire de packages NuGet :

dotnet add package IronPdf

dotnet add package IronPdf

Vous pouvez également utiliser la console du gestionnaire de packages de Visual Studio :

Install-Package IronPdf

Install-Package IronPdf

Après l'installation, vérifiez que la référence du package apparaît bien dans votre fichier .csproj. IronPDF cible Windows sur .NET 6 et versions ultérieures ; par conséquent, si vous utilisez une cible multiplateforme dans votre fichier de projet, ajoutez une restriction <RuntimeIdentifiers> ou <Platforms> pour Windows. Pour les projets Windows Forms, cette configuration est généralement déjà effectuée lors de la création du modèle de projet dans Visual Studio.

Pour la gestion des licences en production, placez votre clé de licence dans le code de démarrage de votre application avant tout appel à IronPDF :

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Lors des phases de développement et d'évaluation, IronPDF fonctionne en mode d'essai, ce qui ajoute un filigrane au rendu. Une licence d'essai gratuite supprime le filigrane à des fins de test.

Comment configurer la structure d'un projet Windows Forms ?

Ouvrez Visual Studio et créez un nouveau projet d'application Windows Forms ciblant .NET 10. Le modèle de projet génère un point d'entrée Form1.cs et un point d'entrée Program.cs.

Sur l'interface de conception, ajoutez les contrôles suivants à votre formulaire :

• Un PictureBox nommé pictureBoxPdf couvrant la majeure partie du formulaire, avec SizeMode défini sur Zoom
• Un Button nommé btnOpen avec le texte " Ouvrir le PDF "
• Un Button nommé btnPrevious avec le texte " Précédent "
• Un Button nommé btnNext avec le texte " Suivant "
• Un Button nommé btnSave avec le texte " Enregistrer la page "
• Un Button nommé btnPrint avec le texte " Imprimer "
• Un Label nommé lblPageInfo pour afficher le numéro de page actuel

Le paramètre SizeMode = Zoom sur le PictureBox garantit que les pages PDF s'adaptent proportionnellement à la zone de contrôle sans déformer le rapport hauteur/largeur. C'est important car les pages PDF ont des tailles variables : les formats lettre, A4 et légal ont tous des dimensions différentes, et vous voulez que le visualiseur puisse tous les gérer correctement.

Vous trouverez ci-dessous le code complet du formulaire pour l'application de visualisation PDF. Cela utilise des instructions de niveau supérieur dans Program.cs et place la logique complète du visualiseur dans Form1.cs :

using IronPdf;
using IronSoftware.Drawing;
using System.Drawing;

public partial class Form1 : Form
{
    private PdfDocument? currentPdf;
    private AnyBitmap[]? pageImages;
    private int currentPageIndex = 0;

    public Form1()
    {
        InitializeComponent();
        pictureBoxPdf.SizeMode = PictureBoxSizeMode.Zoom;
        UpdateNavigationState();
    }

    private void UpdateNavigationState()
    {
        bool hasPdf = pageImages != null && pageImages.Length > 0;
        btnPrevious.Enabled = hasPdf && currentPageIndex > 0;
        btnNext.Enabled = hasPdf && currentPageIndex < (pageImages?.Length - 1 ?? 0);
        btnSave.Enabled = hasPdf;
        btnPrint.Enabled = hasPdf;
        lblPageInfo.Text = hasPdf
            ? $"Page {currentPageIndex + 1} of {pageImages!.Length}"
            : "No document loaded";
    }
}

using IronPdf;
using IronSoftware.Drawing;
using System.Drawing;

public partial class Form1 : Form
{
    private PdfDocument? currentPdf;
    private AnyBitmap[]? pageImages;
    private int currentPageIndex = 0;

    public Form1()
    {
        InitializeComponent();
        pictureBoxPdf.SizeMode = PictureBoxSizeMode.Zoom;
        UpdateNavigationState();
    }

    private void UpdateNavigationState()
    {
        bool hasPdf = pageImages != null && pageImages.Length > 0;
        btnPrevious.Enabled = hasPdf && currentPageIndex > 0;
        btnNext.Enabled = hasPdf && currentPageIndex < (pageImages?.Length - 1 ?? 0);
        btnSave.Enabled = hasPdf;
        btnPrint.Enabled = hasPdf;
        lblPageInfo.Text = hasPdf
            ? $"Page {currentPageIndex + 1} of {pageImages!.Length}"
            : "No document loaded";
    }
}

Imports IronPdf
Imports IronSoftware.Drawing
Imports System.Drawing

Public Partial Class Form1
    Inherits Form

    Private currentPdf As PdfDocument
    Private pageImages As AnyBitmap()
    Private currentPageIndex As Integer = 0

    Public Sub New()
        InitializeComponent()
        pictureBoxPdf.SizeMode = PictureBoxSizeMode.Zoom
        UpdateNavigationState()
    End Sub

    Private Sub UpdateNavigationState()
        Dim hasPdf As Boolean = pageImages IsNot Nothing AndAlso pageImages.Length > 0
        btnPrevious.Enabled = hasPdf AndAlso currentPageIndex > 0
        btnNext.Enabled = hasPdf AndAlso currentPageIndex < If(pageImages?.Length - 1, 0)
        btnSave.Enabled = hasPdf
        btnPrint.Enabled = hasPdf
        lblPageInfo.Text = If(hasPdf, $"Page {currentPageIndex + 1} of {pageImages.Length}", "No document loaded")
    End Sub
End Class

La méthode d'assistance UpdateNavigationState désactive ou active les boutons de navigation et d'action selon qu'un PDF a été chargé et quelle page le visualiseur affiche actuellement. Cela évite les erreurs de référence nulle lorsque les utilisateurs cliquent sur des boutons avant le chargement d'un document.

Comment charger et afficher des pages PDF dans un contrôle PictureBox ?

Le chargement d'un PDF et son rendu dans le PictureBox impliquent deux étapes : le chargement du document avec PdfDocument.FromFile, puis l'appel de ToBitmap pour convertir toutes les pages en un tableau d'objets bitmap.

La méthode de conversion PDF en image ToBitmap rend chaque page du PDF au DPI demandé. Une résolution DPI plus élevée produit des images plus nettes, mais utilise plus de mémoire. Une valeur de 150 DPI offre généralement un bon compromis pour une visionneuse de documents : une lecture à l'écran est possible sans nécessiter des gigaoctets de RAM pour les documents volumineux.

private void btnOpen_Click(object sender, EventArgs e)
{
    using OpenFileDialog openDialog = new OpenFileDialog();
    openDialog.Filter = "PDF Files|*.pdf";
    openDialog.Title = "Select a PDF Document";

    if (openDialog.ShowDialog() == DialogResult.OK)
    {
        LoadPdfDocument(openDialog.FileName);
    }
}

private void LoadPdfDocument(string filePath)
{
    currentPdf?.Dispose();
    currentPdf = PdfDocument.FromFile(filePath);

    // Render all pages as bitmaps at 150 DPI
    pageImages = currentPdf.ToBitmap(150);
    currentPageIndex = 0;

    DisplayCurrentPage();
    UpdateNavigationState();
}

private void DisplayCurrentPage()
{
    if (pageImages == null || pageImages.Length == 0) return;

    // Convert AnyBitmap to System.Drawing.Bitmap for PictureBox
    System.Drawing.Bitmap bitmap = pageImages[currentPageIndex].ToImage<System.Drawing.Bitmap>();
    pictureBoxPdf.Image?.Dispose();
    pictureBoxPdf.Image = bitmap;

    UpdateNavigationState();
}

private void btnOpen_Click(object sender, EventArgs e)
{
    using OpenFileDialog openDialog = new OpenFileDialog();
    openDialog.Filter = "PDF Files|*.pdf";
    openDialog.Title = "Select a PDF Document";

    if (openDialog.ShowDialog() == DialogResult.OK)
    {
        LoadPdfDocument(openDialog.FileName);
    }
}

private void LoadPdfDocument(string filePath)
{
    currentPdf?.Dispose();
    currentPdf = PdfDocument.FromFile(filePath);

    // Render all pages as bitmaps at 150 DPI
    pageImages = currentPdf.ToBitmap(150);
    currentPageIndex = 0;

    DisplayCurrentPage();
    UpdateNavigationState();
}

private void DisplayCurrentPage()
{
    if (pageImages == null || pageImages.Length == 0) return;

    // Convert AnyBitmap to System.Drawing.Bitmap for PictureBox
    System.Drawing.Bitmap bitmap = pageImages[currentPageIndex].ToImage<System.Drawing.Bitmap>();
    pictureBoxPdf.Image?.Dispose();
    pictureBoxPdf.Image = bitmap;

    UpdateNavigationState();
}

Private Sub btnOpen_Click(sender As Object, e As EventArgs) Handles btnOpen.Click
    Using openDialog As New OpenFileDialog()
        openDialog.Filter = "PDF Files|*.pdf"
        openDialog.Title = "Select a PDF Document"

        If openDialog.ShowDialog() = DialogResult.OK Then
            LoadPdfDocument(openDialog.FileName)
        End If
    End Using
End Sub

Private Sub LoadPdfDocument(filePath As String)
    currentPdf?.Dispose()
    currentPdf = PdfDocument.FromFile(filePath)

    ' Render all pages as bitmaps at 150 DPI
    pageImages = currentPdf.ToBitmap(150)
    currentPageIndex = 0

    DisplayCurrentPage()
    UpdateNavigationState()
End Sub

Private Sub DisplayCurrentPage()
    If pageImages Is Nothing OrElse pageImages.Length = 0 Then Return

    ' Convert AnyBitmap to System.Drawing.Bitmap for PictureBox
    Dim bitmap As System.Drawing.Bitmap = pageImages(currentPageIndex).ToImage(Of System.Drawing.Bitmap)()
    pictureBoxPdf.Image?.Dispose()
    pictureBoxPdf.Image = bitmap

    UpdateNavigationState()
End Sub

La méthode PdfDocument.FromFile charge le PDF depuis le disque en mémoire. L'appel de ToBitmap avec un paramètre DPI renvoie un tableau d'objets AnyBitmap, un par page. Le type AnyBitmap est la classe bitmap indépendante du format d'IronPDF, et ToImage<System.Drawing.Bitmap>() la convertit en type System.Drawing.Bitmap que PictureBox.Image attend.

Notez que le précédent PictureBox.Image est supprimé avant l'attribution d'un nouveau. Ceci est important -- chaque objet Bitmap contient des ressources GDI+ non gérées, et le fait de ne pas libérer les anciennes bitmaps provoque des fuites de mémoire dans les applications de longue durée.

Après le chargement, la visionneuse affiche immédiatement la première page. L'étiquette lblPageInfo se met à jour pour afficher le numéro de page actuel et le nombre total de pages.

Comment ajouter une navigation entre les pages d'un PDF ?

Un visualiseur PDF qui n'affiche que la première page n'est pas utile pour les documents de plusieurs pages. Les boutons de navigation permettent aux utilisateurs de se déplacer vers l'avant et vers l'arrière dans le tableau de pages rendu :

private void btnPrevious_Click(object sender, EventArgs e)
{
    if (currentPageIndex > 0)
    {
        currentPageIndex--;
        DisplayCurrentPage();
    }
}

private void btnNext_Click(object sender, EventArgs e)
{
    if (pageImages != null && currentPageIndex < pageImages.Length - 1)
    {
        currentPageIndex++;
        DisplayCurrentPage();
    }
}

private void btnPrevious_Click(object sender, EventArgs e)
{
    if (currentPageIndex > 0)
    {
        currentPageIndex--;
        DisplayCurrentPage();
    }
}

private void btnNext_Click(object sender, EventArgs e)
{
    if (pageImages != null && currentPageIndex < pageImages.Length - 1)
    {
        currentPageIndex++;
        DisplayCurrentPage();
    }
}

Private Sub btnPrevious_Click(sender As Object, e As EventArgs)
    If currentPageIndex > 0 Then
        currentPageIndex -= 1
        DisplayCurrentPage()
    End If
End Sub

Private Sub btnNext_Click(sender As Object, e As EventArgs)
    If pageImages IsNot Nothing AndAlso currentPageIndex < pageImages.Length - 1 Then
        currentPageIndex += 1
        DisplayCurrentPage()
    End If
End Sub

Chaque gestionnaire de clic ajuste la valeur de currentPageIndex d'une unité et appelle DisplayCurrentPage, qui remplace PictureBox.Image par l'image bitmap correspondante. Les vérifications de limites (currentPageIndex > 0 et currentPageIndex < pageImages.Length - 1) empêchent les exceptions d'index hors limites, bien que UpdateNavigationState désactive également les boutons lorsqu'ils sont hors de portée.

Pour les documents volumineux, vous pouvez également envisager d'ajouter un champ de saisie du numéro de page permettant aux utilisateurs d'accéder directement à la page souhaitée, ou une barre de vignettes défilante sur le côté. Le tableau pageImages contient déjà toutes les pages rendues ; accéder à une page quelconque consiste donc simplement à définir currentPageIndex sur l'index cible et à appeler DisplayCurrentPage.

Comment enregistrer et imprimer des pages PDF à partir de la visionneuse ?

Les visionneuses de documents doivent généralement permettre à la fois d'enregistrer la page actuelle sous forme de fichier image et d'envoyer le document à une imprimante. IronPDF simplifie les deux.

private void btnSave_Click(object sender, EventArgs e)
{
    if (pictureBoxPdf.Image == null) return;

    using SaveFileDialog saveDialog = new SaveFileDialog();
    saveDialog.Filter = "PNG Image|*.png|JPEG Image|*.jpg|TIFF Image|*.tif";
    saveDialog.Title = "Save Page As Image";
    saveDialog.FileName = $"page_{currentPageIndex + 1}";

    if (saveDialog.ShowDialog() == DialogResult.OK)
    {
        pictureBoxPdf.Image.Save(saveDialog.FileName);
    }
}

private void btnSave_Click(object sender, EventArgs e)
{
    if (pictureBoxPdf.Image == null) return;

    using SaveFileDialog saveDialog = new SaveFileDialog();
    saveDialog.Filter = "PNG Image|*.png|JPEG Image|*.jpg|TIFF Image|*.tif";
    saveDialog.Title = "Save Page As Image";
    saveDialog.FileName = $"page_{currentPageIndex + 1}";

    if (saveDialog.ShowDialog() == DialogResult.OK)
    {
        pictureBoxPdf.Image.Save(saveDialog.FileName);
    }
}

Private Sub btnSave_Click(sender As Object, e As EventArgs)
    If pictureBoxPdf.Image Is Nothing Then Return

    Using saveDialog As New SaveFileDialog()
        saveDialog.Filter = "PNG Image|*.png|JPEG Image|*.jpg|TIFF Image|*.tif"
        saveDialog.Title = "Save Page As Image"
        saveDialog.FileName = $"page_{currentPageIndex + 1}"

        If saveDialog.ShowDialog() = DialogResult.OK Then
            pictureBoxPdf.Image.Save(saveDialog.FileName)
        End If
    End Using
End Sub

private void btnPrint_Click(object sender, EventArgs e)
{
    if (currentPdf == null) return;

    using PrintDialog printDialog = new PrintDialog();
    if (printDialog.ShowDialog() == DialogResult.OK)
    {
        currentPdf.Print();
    }
}

private void btnPrint_Click(object sender, EventArgs e)
{
    if (currentPdf == null) return;

    using PrintDialog printDialog = new PrintDialog();
    if (printDialog.ShowDialog() == DialogResult.OK)
    {
        currentPdf.Print();
    }
}

Private Sub btnPrint_Click(sender As Object, e As EventArgs)
    If currentPdf Is Nothing Then Return

    Using printDialog As New PrintDialog()
        If printDialog.ShowDialog() = DialogResult.OK Then
            currentPdf.Print()
        End If
    End Using
End Sub

Comment gérer correctement la mémoire et son élimination ?

Les documents PDF et les images bitmap rendues consomment une quantité importante de mémoire, notamment avec des paramètres DPI élevés ou pour les documents volumineux. Sans une suppression appropriée, une application de visualisation fonctionnant pendant une longue période épuisera progressivement la mémoire disponible.

protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        currentPdf?.Dispose();
        pictureBoxPdf.Image?.Dispose();

        if (pageImages != null)
        {
            foreach (var bitmap in pageImages)
                bitmap.Dispose();
        }

        components?.Dispose();
    }
    base.Dispose(disposing);
}

protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        currentPdf?.Dispose();
        pictureBoxPdf.Image?.Dispose();

        if (pageImages != null)
        {
            foreach (var bitmap in pageImages)
                bitmap.Dispose();
        }

        components?.Dispose();
    }
    base.Dispose(disposing);
}

Protected Overrides Sub Dispose(disposing As Boolean)
    If disposing Then
        currentPdf?.Dispose()
        pictureBoxPdf.Image?.Dispose()

        If pageImages IsNot Nothing Then
            For Each bitmap In pageImages
                bitmap.Dispose()
            Next
        End If

        components?.Dispose()
    End If
    MyBase.Dispose(disposing)
End Sub

Comment afficher uniquement la page visible au lieu de toutes les pages ?

Pour les fichiers PDF volumineux comportant des dizaines ou des centaines de pages, l'affichage de toutes les pages en amont peut s'avérer lent et gourmand en mémoire. Une approche plus efficace consiste à n'afficher que la page que l'utilisateur souhaite consulter, à la demande.

L'approche RasterizeToImageFiles d'IronPDF prend en charge le rendu page par page, mais pour une utilisation en mémoire, vous pouvez également utiliser PageCount et rendre une seule page à la fois :

private void DisplayPageLazy(int pageIndex)
{
    if (currentPdf == null) return;

    // Render only the requested page
    AnyBitmap[] singlePage = currentPdf.ToBitmap(150, pageIndex, pageIndex);

    System.Drawing.Bitmap bitmap = singlePage[0].ToImage<System.Drawing.Bitmap>();
    pictureBoxPdf.Image?.Dispose();
    pictureBoxPdf.Image = bitmap;

    singlePage[0].Dispose();

    lblPageInfo.Text = $"Page {pageIndex + 1} of {currentPdf.PageCount}";
    UpdateNavigationState();
}

private void DisplayPageLazy(int pageIndex)
{
    if (currentPdf == null) return;

    // Render only the requested page
    AnyBitmap[] singlePage = currentPdf.ToBitmap(150, pageIndex, pageIndex);

    System.Drawing.Bitmap bitmap = singlePage[0].ToImage<System.Drawing.Bitmap>();
    pictureBoxPdf.Image?.Dispose();
    pictureBoxPdf.Image = bitmap;

    singlePage[0].Dispose();

    lblPageInfo.Text = $"Page {pageIndex + 1} of {currentPdf.PageCount}";
    UpdateNavigationState();
}

Private Sub DisplayPageLazy(pageIndex As Integer)
    If currentPdf Is Nothing Then Return

    ' Render only the requested page
    Dim singlePage As AnyBitmap() = currentPdf.ToBitmap(150, pageIndex, pageIndex)

    Dim bitmap As System.Drawing.Bitmap = singlePage(0).ToImage(Of System.Drawing.Bitmap)()
    pictureBoxPdf.Image?.Dispose()
    pictureBoxPdf.Image = bitmap

    singlePage(0).Dispose()

    lblPageInfo.Text = $"Page {pageIndex + 1} of {currentPdf.PageCount}"
    UpdateNavigationState()
End Sub

La surcharge ToBitmap(dpi, startPage, endPage) rend une plage de pages spécifique. En utilisant le même index pour startPage et endPage, une seule page est rendue à la fois. Ce procédé privilégie le temps de rendu par navigation au détriment d'une consommation mémoire maximale plus faible, ce qui peut s'avérer avantageux pour les documents très volumineux.

Pour en savoir plus sur les capacités de sortie d'images d'IronPDF, consultez la documentation PDF vers image et le guide de rastérisation PDF .

Un lecteur PDF pratique doit également permettre aux utilisateurs de Zoom sur le contenu et de faire pivoter les pages. Pour le Zoom, ajustez dynamiquement le DPI transmis à ToBitmap -- stockez un champ currentDpi (commençant à 150), incrémentez-le ou décrémentez-le de 50 sur les clics sur le bouton de Zoom , puis appelez le rendu de page paresseux avec le DPI mis à jour. Un DPI plus élevé produit une image plus grande, que le PictureBox en mode Zoom met à l'échelle pour s'adapter à la commande. Limitez la plage entre 72 et 400 DPI en utilisant Math.Min et Math.Max pour éviter soit une sortie floue à la limite inférieure, soit une consommation excessive de mémoire à la limite supérieure.

Pour des options de rendu plus avancées, notamment l'extraction de texte à partir de PDF en plus du rendu d'images, consultez le guide d'extraction de texte PDF et la documentation sur l'extraction d'images PDF .

Vous pouvez également explorer les fonctionnalités d'IronPDF permettant de fusionner des documents PDF , d'ajouter des filigranes , de faire pivoter les pages PDF et d'ajouter des annotations, grâce à une visionneuse plus avancée.

Comment choisir une bibliothèque de rendu PDF pour Windows Forms ?

Plusieurs bibliothèques de rendu PDF existent pour Windows Forms. Voici un tableau comparatif pour vous aider à évaluer les différentes options :

Le principal avantage d'IronPDF pour les cas d'utilisation de Windows Forms est qu'il est entièrement autonome : aucun logiciel externe n'a besoin d'être installé sur les machines des utilisateurs finaux. La page de licence IronPDF contient tous les détails concernant les tarifs et l'option d'essai gratuit. Vous trouverez le package sur NuGet, ainsi que les statistiques de téléchargement et l'historique des versions. Pour une analyse plus approfondie de la manière dont la spécification PDF définit le rendu des pages, la norme PDF ISO 32000-2 publiée par l'ISO décrit le format IronPDF et d'autres moteurs de rendu doivent implémenter.

Pour plus d'informations sur les capacités d'IronPDF au-delà du rendu d'images, la documentation IronPDF couvre la création de PDF, la conversion HTML vers PDF, la gestion des formulaires, les signatures numériques et bien plus encore.

Quelles sont vos prochaines étapes ?

Le modèle présenté dans ce tutoriel -- rendu avec ToBitmap, affichage dans PictureBox, navigation avec des contrôles basés sur l'index -- vous donne une visionneuse PDF fonctionnelle et sans dépendance dans Windows Forms. À partir de là, plusieurs pistes méritent d'être explorées en fonction des exigences de votre application.

Pour une visionneuse de qualité professionnelle, envisagez le rendu différé des pages pour gérer efficacement les documents volumineux, l'ajout d'un panneau de vignettes défilable à côté de la visionneuse principale et l'exposition de commandes de Zoom liées au paramètre DPI. Pour les applications de gestion de documents, combinez la visionneuse avec les capacités d'extraction de texte et de lecture des champs de formulaire d'IronPDF pour créer des index de documents consultables.

Si votre flux de travail implique la génération de PDF par programmation avant leur affichage, IronPDF prend également en charge la conversion HTML vers PDF et la création de PDF à partir de zéro ; la même bibliothèque gère donc à la fois la génération et l'affichage.

Démarrez un essai gratuit pour obtenir une clé de licence sans filigrane pour le développement, ou consultez la référence API complète pour voir l'ensemble complet des méthodes disponibles sur PdfDocument, AnyBitmap et les classes de rendu de support. La galerie d'exemples IronPDF contient également des exemples de code prêts à l'emploi couvrant les tâches PDF courantes en C#.