Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. C# ouvrir PDF dans le visionneur par défaut
UTILISATION DE IRONPDF

Ouvrir un PDF en C# dans la visionneuse par défaut avec IronPDF (.NET 10)

Curtis Chau
Curtis Chau
Mis à jour:

Ouvrir un fichier PDF dans la visionneuse par défaut est une tâche courante dans le développement d'applications .NET . Après avoir généré des fichiers PDF par programmation avec IronPDF , vous devez souvent les afficher immédiatement aux utilisateurs dans l'application par défaut qu'ils ont choisie, telle qu'Adobe Acrobat ou Microsoft Edge. Ce guide vous présente les étapes à suivre pour générer des fichiers PDF à l'aide d'IronPDF et les ouvrir automatiquement dans Windows à l'aide d'System.Diagnostics.Process.Start.

La combinaison des puissantes capacités de conversion HTML-to-PDF d'IronPDF avec la méthode de lancement simple Process crée un flux de travail pratique pour la construction et l'affichage de fichiers PDF professionnels dans l'application par défaut configurée sur la machine d'un utilisateur.

Comment installer IronPDF dans un projet .NET ?

Avant de générer ou d'ouvrir un fichier PDF, vous devez installer IronPDF dans votre projet. Utilisez soit la console du gestionnaire de packages NuGet , soit l'interface de ligne de commande .NET :

Install-Package IronPdf
dotnet add package IronPdf
Install-Package IronPdf
dotnet add package IronPdf
SHELL

Après l'installation, ajoutez votre clé de licence ou commencez par un essai gratuit pour activer toutes les fonctionnalités. La documentation IronPDF couvre toutes les options de configuration en détail, y compris l'installation via NuGet.

Une fois installé, vous aurez accès à l'ensemble des fonctionnalités IronPDF , notamment la conversion HTML vers PDF, le rendu d'URL, la fusion de PDF, le marquage en filigrane, la signature numérique et bien plus encore.

Comment générer et ouvrir un fichier PDF ?

L'approche la plus simple implique trois étapes :

  1. Créer un document PDF avec IronPDF.
  2. Enregistrer le fichier dans un répertoire.
  3. Ouvrez le PDF dans l'application par défaut en utilisant Process.Start.

Voici un exemple complet et fonctionnel que vous pouvez essayer dans Visual Studio avec un nouveau projet d'application console :

using IronPdf;
using System.Diagnostics;

// Create a new PDF renderer
var renderer = new ChromePdfRenderer();

// Generate PDF from HTML content
var pdf = renderer.RenderHtmlAsPdf(@"
    <html>
        <body>
            <h1>Invoice #12345</h1>
            <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
            <table>
                <tr><td>Product</td><td>Price</td></tr>
                <tr><td>IronPDF License</td><td>$299</td></tr>
            </table>
        </body>
    </html>");

// Save the PDF to a file
string outputPath = "invoice.pdf";
pdf.SaveAs(outputPath);

// Open the PDF in the default viewer
Process.Start(new ProcessStartInfo
{
    FileName = outputPath,
    UseShellExecute = true
});
using IronPdf;
using System.Diagnostics;

// Create a new PDF renderer
var renderer = new ChromePdfRenderer();

// Generate PDF from HTML content
var pdf = renderer.RenderHtmlAsPdf(@"
    <html>
        <body>
            <h1>Invoice #12345</h1>
            <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
            <table>
                <tr><td>Product</td><td>Price</td></tr>
                <tr><td>IronPDF License</td><td>$299</td></tr>
            </table>
        </body>
    </html>");

// Save the PDF to a file
string outputPath = "invoice.pdf";
pdf.SaveAs(outputPath);

// Open the PDF in the default viewer
Process.Start(new ProcessStartInfo
{
    FileName = outputPath,
    UseShellExecute = true
});
Imports IronPdf
Imports System.Diagnostics

' Create a new PDF renderer
Dim renderer As New ChromePdfRenderer()

' Generate PDF from HTML content
Dim pdf = renderer.RenderHtmlAsPdf("
    <html>
        <body>
            <h1>Invoice #12345</h1>
            <p>Generated on: " & DateTime.Now.ToString("yyyy-MM-dd") & "</p>
            <table>
                <tr><td>Product</td><td>Price</td></tr>
                <tr><td>IronPDF License</td><td>$299</td></tr>
            </table>
        </body>
    </html>")

' Save the PDF to a file
Dim outputPath As String = "invoice.pdf"
pdf.SaveAs(outputPath)

' Open the PDF in the default viewer
Process.Start(New ProcessStartInfo With {
    .FileName = outputPath,
    .UseShellExecute = True
})
$vbLabelText   $csharpLabel

Ce code crée d'abord une instance ChromePdfRenderer, qui est la classe principale d'IronPDF pour la conversion de HTML en PDF. La méthode RenderHtmlAsPdf convertit la chaîne HTML en un objet document PDF. Pour en savoir plus sur cette approche, consultez le guide HTML-to-PDF d'IronPDF .

Après avoir enregistré le PDF à l'aide du SaveAs, le code utilise le Process.Start avec le ProcessStartInfo pour ouvrir le fichier dans la visionneuse PDF par défaut. Le paramètre clé ici est UseShellExecute = true, qui indique à Windows d'ouvrir le fichier PDF avec son application par défaut.

Sortie

Comme le montre l'image ci-dessous, IronPDF génère avec succès le fichier PDF et l'affiche à l'aide du visualiseur par défaut configuré sur le système, en l'occurrence Opera GX.

Comment ouvrir des PDF dans le visualiseur par défaut en C# : Figure 1 - PDF affiché en utilisant le visualiseur par défaut

Pourquoi des déclarations de niveau supérieur ?

Avec .NET 10 et les versions modernes de C#, les déclarations de premier niveau éliminent la nécessité d'un Program wrapper de classe. Le code s'exécute directement en haut du fichier, ce qui rend les exemples plus courts et plus faciles à suivre. Tous les exemples de ce guide utilisent ce modèle.

Pourquoi l'option UseShellExecute est-elle importante lors de l'ouverture de documents PDF ?

Dans .NET Core et les versions modernes de .NET (.NET 5 à .NET 10), le paramètre UseShellExecute prend par défaut la valeur false. Si vous ne lui attribuez pas explicitement la valeur true, votre application génèrera une erreur lorsqu'elle essaiera de lancer un fichier PDF.

using IronPdf;
using System.Diagnostics;
using System.IO;

// Generate a report with IronPDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;

var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/Main_Page");

// Save to temp directory for immediate viewing
string tempPath = Path.Combine(Path.GetTempPath(), $"URL_{Guid.NewGuid()}.pdf");
pdf.SaveAs(tempPath);

// IMPORTANT: Set UseShellExecute = true for .NET Core/5+
var startInfo = new ProcessStartInfo
{
    FileName = tempPath,
    UseShellExecute = true  // Required in .NET Core/5+ to open PDF in default viewer
};
Process.Start(startInfo);
using IronPdf;
using System.Diagnostics;
using System.IO;

// Generate a report with IronPDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;

var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/Main_Page");

// Save to temp directory for immediate viewing
string tempPath = Path.Combine(Path.GetTempPath(), $"URL_{Guid.NewGuid()}.pdf");
pdf.SaveAs(tempPath);

// IMPORTANT: Set UseShellExecute = true for .NET Core/5+
var startInfo = new ProcessStartInfo
{
    FileName = tempPath,
    UseShellExecute = true  // Required in .NET Core/5+ to open PDF in default viewer
};
Process.Start(startInfo);
Imports IronPdf
Imports System.Diagnostics
Imports System.IO

' Generate a report with IronPDF
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 50
renderer.RenderingOptions.MarginBottom = 50

Dim pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/Main_Page")

' Save to temp directory for immediate viewing
Dim tempPath As String = Path.Combine(Path.GetTempPath(), $"URL_{Guid.NewGuid()}.pdf")
pdf.SaveAs(tempPath)

' IMPORTANT: Set UseShellExecute = true for .NET Core/5+
Dim startInfo As New ProcessStartInfo With {
    .FileName = tempPath,
    .UseShellExecute = True  ' Required in .NET Core/5+ to open PDF in default viewer
}
Process.Start(startInfo)
$vbLabelText   $csharpLabel

La propriété UseShellExecute détermine s'il faut utiliser le shell du système d'exploitation pour lancer le processus. Lorsque ce paramètre est défini sur true, Windows utilise le registre d'association de fichiers pour déterminer quel lecteur PDF par défaut doit ouvrir le fichier. Sans ce paramètre dans les versions modernes de .NET, vous rencontrerez une erreur d'exécution indiquant que le fichier ne peut pas être ouvert.

L'utilisation d'un répertoire temporaire avec un nom de fichier unique (via Guid.NewGuid()) permet d'éviter les conflits de fichiers lors de la génération de plusieurs PDF en succession rapide. Le dossier temporaire par défaut est nettoyé automatiquement par le système d'exploitation à intervalles réguliers.

Sortie

Comment ouvrir des PDF dans le visualiseur par défaut en C# : Figure 2 - URL vers PDF généré et affiché en utilisant le visualiseur par défaut

Comment gérer correctement les chemins d'accès aux fichiers ?

Les chemins d'accès aux fichiers contenant des espaces et des caractères spéciaux nécessitent une manipulation soigneuse. Un répertoire manquant ou un chemin d'accès mal formé entraînera un échec silencieux ou une exception avant que Process.Start ne soit atteint. Voici une approche qui inclut la création de répertoires et la vérification de l'existence des fichiers :

using IronPdf;
using System.Diagnostics;
using System.IO;

// Generate PDF from HTML file
var renderer = new ChromePdfRenderer();
var htmlContent = File.ReadAllText("template.html");
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Create output directory if it doesn't exist
string outputDir = @"C:\PDF Reports\Monthly";
Directory.CreateDirectory(outputDir);

// Build file path with timestamp
string fileName = $"Report_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";
string fullPath = Path.Combine(outputDir, fileName);

// Save the PDF
pdf.SaveAs(fullPath);

// Verify file exists before opening in default PDF viewer
if (File.Exists(fullPath))
{
    Process.Start(new ProcessStartInfo
    {
        FileName = fullPath,
        UseShellExecute = true
    });
}
else
{
    Console.WriteLine($"Error: PDF file not found at {fullPath}");
}
using IronPdf;
using System.Diagnostics;
using System.IO;

// Generate PDF from HTML file
var renderer = new ChromePdfRenderer();
var htmlContent = File.ReadAllText("template.html");
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Create output directory if it doesn't exist
string outputDir = @"C:\PDF Reports\Monthly";
Directory.CreateDirectory(outputDir);

// Build file path with timestamp
string fileName = $"Report_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";
string fullPath = Path.Combine(outputDir, fileName);

// Save the PDF
pdf.SaveAs(fullPath);

// Verify file exists before opening in default PDF viewer
if (File.Exists(fullPath))
{
    Process.Start(new ProcessStartInfo
    {
        FileName = fullPath,
        UseShellExecute = true
    });
}
else
{
    Console.WriteLine($"Error: PDF file not found at {fullPath}");
}
Imports IronPdf
Imports System.Diagnostics
Imports System.IO

' Generate PDF from HTML file
Dim renderer As New ChromePdfRenderer()
Dim htmlContent As String = File.ReadAllText("template.html")
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

' Create output directory if it doesn't exist
Dim outputDir As String = "C:\PDF Reports\Monthly"
Directory.CreateDirectory(outputDir)

' Build file path with timestamp
Dim fileName As String = $"Report_{DateTime.Now:yyyyMMdd_HHmmss}.pdf"
Dim fullPath As String = Path.Combine(outputDir, fileName)

' Save the PDF
pdf.SaveAs(fullPath)

' Verify file exists before opening in default PDF viewer
If File.Exists(fullPath) Then
    Process.Start(New ProcessStartInfo With {
        .FileName = fullPath,
        .UseShellExecute = True
    })
Else
    Console.WriteLine($"Error: PDF file not found at {fullPath}")
End If
$vbLabelText   $csharpLabel

Ce code démontre plusieurs bonnes pratiques : l'utilisation de Path.Combine pour construire des chemins de fichiers correctement quel que soit le système d'exploitation, la création de répertoires selon les besoins avec Directory.CreateDirectory, et la vérification de l'existence des fichiers avant d'essayer d'ouvrir le PDF dans le visualiseur par défaut.

Le horodatage dans le nom du fichier assure l'unicité et fournit un enregistrement clair du moment où chaque PDF a été généré. Pour des options avancées de manipulation de PDF telles que la fusion ou la division de PDF , l'ajout de filigranes , la signature numérique , ainsi que les en-têtes et pieds de page , consultez les guides pratiques d'IronPDF.

Qu'en est-il des chemins avec des espaces ?

Path.Combine gère correctement les espaces car il construit les chemins d'accès sous forme de chaînes plutôt que de s'appuyer sur l'expansion de l'interpréteur de commandes. La classe ProcessStartInfo gère également correctement les chemins entre guillemets lorsque UseShellExecute = true. Si vous devez passer un chemin d'accès directement à une commande shell, entourez-le toujours de guillemets doubles. Avec Process.Start, la propriété FileName ne nécessite pas de citation manuelle.

Comment appliquer les meilleures pratiques prêtes pour la production ?

Pour les applications de production, envisagez un flux de travail plus complet qui gère le cycle de vie du PDF avec la gestion des erreurs, des options de rendu configurables et des répertoires de sortie prévisibles :

using IronPdf;
using IronPdf.Rendering;
using System.Diagnostics;
using System.IO;

static void GenerateAndDisplayPdf(string htmlContent, string documentName)
{
    try
    {
        // Configure IronPDF renderer with production settings
        var renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                PaperSize = PdfPaperSize.A4,
                PrintHtmlBackgrounds = true,
                CreatePdfFormsFromHtml = true
            }
        };

        // Generate the PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Use the user's Documents folder for better accessibility
        string documentsPath = Environment.GetFolderPath(
            Environment.SpecialFolder.MyDocuments);
        string pdfFolder = Path.Combine(documentsPath, "Generated PDFs");
        Directory.CreateDirectory(pdfFolder);
        string outputPath = Path.Combine(pdfFolder, $"{documentName}.pdf");

        pdf.SaveAs(outputPath);

        // Open PDF in default viewer without waiting for it to close
        Process.Start(new ProcessStartInfo
        {
            FileName = outputPath,
            UseShellExecute = true  // Essential for opening PDF in default application
        });

        Console.WriteLine($"PDF opened: {outputPath}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error generating or opening PDF: {ex.Message}");
    }
}
using IronPdf;
using IronPdf.Rendering;
using System.Diagnostics;
using System.IO;

static void GenerateAndDisplayPdf(string htmlContent, string documentName)
{
    try
    {
        // Configure IronPDF renderer with production settings
        var renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                PaperSize = PdfPaperSize.A4,
                PrintHtmlBackgrounds = true,
                CreatePdfFormsFromHtml = true
            }
        };

        // Generate the PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Use the user's Documents folder for better accessibility
        string documentsPath = Environment.GetFolderPath(
            Environment.SpecialFolder.MyDocuments);
        string pdfFolder = Path.Combine(documentsPath, "Generated PDFs");
        Directory.CreateDirectory(pdfFolder);
        string outputPath = Path.Combine(pdfFolder, $"{documentName}.pdf");

        pdf.SaveAs(outputPath);

        // Open PDF in default viewer without waiting for it to close
        Process.Start(new ProcessStartInfo
        {
            FileName = outputPath,
            UseShellExecute = true  // Essential for opening PDF in default application
        });

        Console.WriteLine($"PDF opened: {outputPath}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error generating or opening PDF: {ex.Message}");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System.Diagnostics
Imports System.IO

Module PdfGenerator

    Sub GenerateAndDisplayPdf(htmlContent As String, documentName As String)
        Try
            ' Configure IronPDF renderer with production settings
            Dim renderer As New ChromePdfRenderer With {
                .RenderingOptions = New ChromePdfRenderOptions With {
                    .PaperSize = PdfPaperSize.A4,
                    .PrintHtmlBackgrounds = True,
                    .CreatePdfFormsFromHtml = True
                }
            }

            ' Generate the PDF
            Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

            ' Use the user's Documents folder for better accessibility
            Dim documentsPath As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
            Dim pdfFolder As String = Path.Combine(documentsPath, "Generated PDFs")
            Directory.CreateDirectory(pdfFolder)
            Dim outputPath As String = Path.Combine(pdfFolder, $"{documentName}.pdf")

            pdf.SaveAs(outputPath)

            ' Open PDF in default viewer without waiting for it to close
            Process.Start(New ProcessStartInfo With {
                .FileName = outputPath,
                .UseShellExecute = True  ' Essential for opening PDF in default application
            })

            Console.WriteLine($"PDF opened: {outputPath}")
        Catch ex As Exception
            Console.WriteLine($"Error generating or opening PDF: {ex.Message}")
        End Try
    End Sub

End Module
$vbLabelText   $csharpLabel

Cet exemple inclut une gestion structurée des erreurs et enregistre les fichiers PDF dans le dossier Documents de l'utilisateur, qui est accessible quelle que soit la manière dont l'application est lancée. Il configure également IronPDF avec des options de rendu adaptées aux documents commerciaux : format de papier A4, impression de fond HTML activée et création automatique de champs de formulaire à partir d'éléments de formulaire HTML.

Vous trouverez plus d'informations sur les formulaires PDF interactifs et les filigranes personnalisés dans la bibliothèque de tutoriels IronPDF .

Cette méthode ne nécessite pas la fermeture du visualiseur PDF, ce qui permet à votre application de continuer à fonctionner pendant que l'utilisateur consulte le document. D'après la documentation Microsoft sur Process.Start , cette approche garantit une gestion correcte des ressources et empêche votre application de se bloquer sur un processus de visualisation de longue durée. La documentation de référence de la classe ProcessStartInfo sur Microsoft Learn fournit une liste complète des propriétés que vous pouvez configurer, notamment le style de fenêtre, le verbe (ouvrir, imprimer) et le répertoire de travail.

Comment ouvrir des PDF dans le visualiseur par défaut en C# : Figure 3 - Génération des PDF au flux de travail d'affichage

Configurer les options de rendu

La classe ChromePdfRenderOptions vous permet de contrôler finement le PDF de sortie. Les paramètres courants comprennent :

  • PaperSize -- Régler sur PdfPaperSize.A4, Letter, ou toute autre taille standard.
  • PrintHtmlBackgrounds -- Affiche les couleurs et les images d'arrière-plan à partir du code HTML.
  • CreatePdfFormsFromHtml -- Convertit les éléments HTML <input> et <select> en champs de formulaire PDF interactifs.
  • MarginTop / MarginBottom / MarginLeft / MarginRight -- Contrôle les marges de la page en millimètres.

Ces paramètres s'appliquent de la même manière, que vous affichiez des chaînes HTML, des fichiers HTML locaux ou des URL distantes.

Comment extraire des données à partir de fichiers PDF générés ?

Une fois le fichier PDF généré et ouvert, vous pourriez également avoir besoin de relire son contenu. IronPDF prend en charge l'extraction de texte à partir de fichiers PDF , ce qui est utile pour la journalisation, la vérification ou le traitement en aval.

Pour les documents contenant de nombreuses images, vous pouvez également utiliser la conversion PDF-image pour convertir les pages individuelles en fichiers PNG ou JPEG. Ceci est courant dans les flux de travail de génération d'aperçus et de vignettes.

Ces deux fonctionnalités sont disponibles via la même bibliothèque IronPDF et ne nécessitent aucune dépendance supplémentaire. La documentation complète de l'API IronPDF fournit des références au niveau des méthodes pour toutes les opérations d'extraction et de conversion.

Que se passe-t-il si aucun lecteur PDF n'est installé ?

Si aucun lecteur PDF n'est installé sur l'ordinateur cible, Windows affichera une boîte de dialogue demandant à l'utilisateur de sélectionner une application ou de se rendre sur le Microsoft Store pour en trouver une. Il s'agit d'un comportement standard de Windows qui échappe au contrôle de Process.Start.

Pour gérer ce problème de manière élégante dans le code de production, vous pouvez attraper le Win32Exception que Process.Start lance lorsqu'aucun gestionnaire enregistré n'est trouvé pour l'extension de fichier .pdf :

using System.ComponentModel;
using System.Diagnostics;

try
{
    Process.Start(new ProcessStartInfo
    {
        FileName = outputPath,
        UseShellExecute = true
    });
}
catch (Win32Exception ex) when (ex.NativeErrorCode == 1155)
{
    // Error 1155: No application associated with the file extension
    Console.WriteLine("No PDF viewer is installed. Please install a PDF reader such as Adobe Acrobat Reader.");
}
using System.ComponentModel;
using System.Diagnostics;

try
{
    Process.Start(new ProcessStartInfo
    {
        FileName = outputPath,
        UseShellExecute = true
    });
}
catch (Win32Exception ex) when (ex.NativeErrorCode == 1155)
{
    // Error 1155: No application associated with the file extension
    Console.WriteLine("No PDF viewer is installed. Please install a PDF reader such as Adobe Acrobat Reader.");
}
Imports System.ComponentModel
Imports System.Diagnostics

Try
    Process.Start(New ProcessStartInfo With {
        .FileName = outputPath,
        .UseShellExecute = True
    })
Catch ex As Win32Exception When ex.NativeErrorCode = 1155
    ' Error 1155: No application associated with the file extension
    Console.WriteLine("No PDF viewer is installed. Please install a PDF reader such as Adobe Acrobat Reader.")
End Try
$vbLabelText   $csharpLabel

Le code d'erreur 1155 correspond à ERROR_NO_ASSOCIATION, que Windows renvoie lorsqu'aucune application n'est enregistrée pour le type de fichier. La détection de cette erreur spécifique permet d'afficher un message utile au lieu de provoquer un plantage. La liste complète des codes d'erreur système Windows est documentée dans la référence des codes d'erreur Win32 sur Microsoft Learn.

Comment choisir la bonne approche pour votre application ?

La méthode que vous choisissez pour ouvrir un fichier PDF dépend du type d'application que vous développez :

Comparaison des stratégies d'ouverture de fichiers PDF pour différents types d'applications
Type d'application Approche recommandée Considération clé
application console ou de bureau Process.Start avec UseShellExecute = true Simple, sans dépendances supplémentaires
Service Windows Enregistrer sur disque ; notifier l'utilisateur via IPC ou file d'attente de messages Les services fonctionnent sans session de bureau
Application Web (ASP.NET) Lecture en continu du PDF sous forme de téléchargement ou directement dans le navigateur La méthode Process.Start n'est pas valide dans le contexte d'un serveur web.
MAUI ou WinForms Process.Start ou contrôle PDF intégré L'affichage intégré offre une meilleure expérience au sein de l'application.

Pour les applications web construites avec ASP.NET Core, n'utilisez pas Process.Start. Le processus serveur s'exécute dans un environnement sans interface graphique et ne peut pas ouvrir d'applications de bureau. Au lieu de cela, renvoyez le PDF en tant que résultat de fichier en utilisant File() avec le type MIME application/pdf, et laissez le navigateur s'occuper de l'affichage.

Pour les applications de console et de bureau, Process.Start avec UseShellExecute = true reste l'option la plus simple et la plus fiable.

Veuillez noterRemarque : Si aucun lecteur PDF n'est installé, Windows peut afficher une boîte de dialogue vous invitant à en sélectionner ou à en télécharger un.

Prêt à commencer la génération et la visualisation de PDF dans votre application .NET ? Commencez par un essai gratuit pour accéder à l'ensemble des fonctionnalités, ou consultez la page des licences IronPDF pour trouver le plan adapté à votre projet.

Questions Fréquemment Posées

Comment puis-je ouvrir un PDF dans le visionneur par défaut en utilisant C# ?

Vous pouvez ouvrir un PDF dans le visionneur par défaut en C# avec IronPDF pour générer le PDF et System.Diagnostics.Process.Start pour l'ouvrir dans l'application PDF par défaut de l'utilisateur.

Qu'est-ce que IronPDF ?

IronPDF est une bibliothèque .NET qui permet aux développeurs de créer, éditer et manipuler des fichiers PDF de manière programmatique dans leurs applications.

Quelles sont les exigences système pour utiliser IronPDF ?

IronPDF est compatible avec toute application .NET et fonctionne sur les plateformes Windows, macOS et Linux. Il nécessite que .NET Framework ou .NET Core/5+ soit installé.

IronPDF peut-il ouvrir des PDF dans Adobe Acrobat par défaut ?

Oui, IronPDF peut générer des PDF qui sont ouverts dans le visionneur PDF par défaut défini par l'utilisateur, qui peut être Adobe Acrobat, Microsoft Edge, ou toute autre application de visualisation de PDF.

Comment System.Diagnostics.Process.Start fonctionne-t-il avec IronPDF ?

System.Diagnostics.Process.Start est utilisé pour ouvrir le fichier PDF généré dans le visionneur par défaut. Une fois qu'IronPDF crée le fichier, cette méthode lance l'application par défaut associée aux fichiers PDF pour l'afficher.

Est-il possible de modifier des fichiers PDF avec IronPDF ?

Oui, IronPDF vous permet de modifier des fichiers PDF existants en ajoutant du texte, des images, des annotations, et plus encore avant de les sauvegarder ou de les afficher.

Quels langages de programmation sont supportés par IronPDF ?

IronPDF est principalement utilisé avec C#, mais il peut également être intégré dans des projets utilisant VB.NET et d'autres langages supportés par .NET.

IronPDF peut-il automatiser l'affichage des PDF après leur génération ?

Oui, après avoir généré un PDF avec IronPDF, vous pouvez automatiser son affichage en using System.Diagnostics.Process.Start pour l'ouvrir immédiatement dans le visionneur par défaut de l'utilisateur.

Existe-t-il des exemples de code disponibles pour l'utilisation d'IronPDF ?

La documentation d'IronPDF fournit divers exemples de code pour générer et manipuler des PDF, y compris comment les ouvrir dans le visionneur par défaut en utilisant C#.

Quels sont les cas d'utilisation courants d'IronPDF ?

Les cas d'utilisation courants pour IronPDF incluent la génération de rapports, de factures et d'autres documents, la conversion HTML en PDF, et l'automatisation du processus d'affichage de PDF dans les applications .NET.

IronPDF est-il compatible avec .NET 10 et quels avantages cela apporte-t-il ?

Oui. IronPDF est entièrement compatible avec .NET 10, y compris ses améliorations d'exécution et de langage. L'utilisation d'IronPDF avec .NET 10 permet à vos applications de bénéficier de performances accrues, telles qu'une réduction de l'allocation de mémoire, une génération de PDF plus rapide et une intégration plus fluide avec les API et plateformes modernes.

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

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi