Comment puis-je convertir HTML en PDF en C# ?

Vous pouvez utiliser la méthode RenderHtmlAsPdf d'IronPDF pour convertir des chaînes HTML en PDFs. Vous pouvez également convertir des fichiers HTML en PDFs en utilisant RenderHtmlFileAsPdf .

Pourquoi la programmation pilotée par événements est-elle importante dans les applications .NET ?

La programmation pilotée par événements est essentielle dans les applications .NET pour améliorer la réactivité et garantir des expériences utilisateur fluides en permettant aux tâches de s'exécuter de manière asynchrone sans bloquer le thread principal.

Comment installer l'outil de génération de PDF nécessaire dans un projet .NET ?

Vous pouvez installer IronPDF via NuGet en exécutant la commande 'Install-Package IronPDF' dans la console du gestionnaire de packages de Visual Studio.

Comment déclarez-vous un événement en C# ?

En C#, les événements sont déclarés à l'aide du mot-clé 'event', souvent avec un type délégué comme 'EventHandler'. Par exemple : public event EventHandler PdfGenerated; .

Qu'est-ce qu'un délégué dans la gestion des événements C# ?

Un délégué en C# est un pointeur de fonction type-safe qui vous permet de définir des méthodes pouvant être appelées en réponse à un événement.

Comment pouvez-vous ajouter des méthodes aux événements en C# ?

Vous pouvez ajouter des méthodes aux événements en C# dynamiquement à l'exécution en utilisant la syntaxe '+=' pour vous abonner aux événements.

Quel est le but de créer une classe EventArgs personnalisée ?

Une classe EventArgs personnalisée est utilisée pour transmettre des données spécifiques à l'événement, telles qu'un chemin de fichier, aux gestionnaires d'événements de manière structurée et type-safe.

Pourquoi devriez-vous utiliser un BackgroundWorker pour générer des PDF volumineux ?

L'utilisation d'un BackgroundWorker vous permet d'exécuter des tâches de génération de PDF de manière asynchrone, empêchant le blocage de l'interface utilisateur et améliorant l'expérience utilisateur.

Quels sont quelques conseils pour travailler avec des événements dans .NET ?

Les conseils clés incluent éviter le blocage du thread de l'interface utilisateur en mettant à jour l'interface uniquement après la fin des tâches en arrière-plan, gérer les exceptions avec soin et se désabonner des événements lorsque plus nécessaire pour éviter les fuites de mémoire.

Quelles sont les alternatives à l'utilisation de gestionnaires d'événements dans .NET ?

Les alternatives incluent l'utilisation de async/await et Task.Run pour les flux de travail plus récents et IProgress pour des mises à jour en temps réel lors d'opérations longues.

La Bibliothèque PDF C#

Explore IronPDF Essai gratuit

HTML en PDF

Online Demo Voir tous les exemples de code %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

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

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

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

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >

Install-Package IronPdf

MISES À JOUR POUR LES DÉVELOPPEURS

C# Event Handler (Comment ça fonctionne pour les développeurs)

Jacob Mellor

Updated: 21 avril 2026

Dans les applications .NET modernes, la programmation événementielle joue un rôle essentiel dans l'amélioration de la réactivité et l'assurance d'expériences utilisateur fluides. Lorsque des tâches comme la génération de PDF prennent du temps, vous ne voulez pas bloquer le thread principal. Au lieu de cela, vous pouvez utiliser des gestionnaires d'événements pour exécuter des tâches de manière asynchrone et réagir une fois qu'un événement se produit, rendant votre application plus interactive et réactive.

Dans ce guide, nous allons vous montrer comment intégrer les méthodes de gestion d'événements C# avec IronPDF pour des flux de travail PDF transparents dans des environnements de bureau et web. Que vous utilisiez WinForms, WPF ou toute autre plateforme basée sur le langage de programmation C#, ce guide couvre vos besoins.

Configuration de Votre Projet IronPDF

Avant de plonger dans la gestion d'événements, configurons rapidement IronPDF dans votre projet .NET.

Installer IronPDF via NuGet

Dans la console du gestionnaire de packages de Visual Studio, exécutez :

PM > Install-Package IronPdf

Install-Package IronPdf

Cela installe tout ce qui est nécessaire pour commencer à générer des PDF avec IronPDF.

Génération de PDF Basique avec IronPDF

Voici un rapide exemple pour vous assurer qu'IronPDF fonctionne :

using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
pdf.SaveAs("example.pdf");

using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
pdf.SaveAs("example.pdf");

Imports IronPdf
Private renderer = New ChromePdfRenderer()
Private pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
pdf.SaveAs("example.pdf")

Imports IronPdf
Private renderer = New ChromePdfRenderer()
Private pdf = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
pdf.SaveAs("example.pdf")

Une fois cela en place, vous êtes prêt à ajouter des champs d'événements, connecter des délégués enregistrés, et utiliser des types de délégués pour créer des flux de travail événementiels.

Principes fondamentaux des gestionnaires d'événements C# pour les développeurs .NET

Les Bases de la Programmation Événementielle

Avec la programmation événementielle, votre application réagit lorsque un événement se produit, tel qu'un PDF terminant sa génération. C# utilise des délégués comme pointeurs de fonction typés de manière sécurisée, vous permettant de définir comment votre application doit réagir.

Vous déclarez généralement des événements en utilisant le mot-clé event, les connectez à des méthodes de gestion d'événements, et passez des données en utilisant des sous-classes personnalisées EventArgs.

Déclarer un Événement avec le Mot-clé event

C# utilise le mot-clé event pour déclarer des membres événements. Par exemple :

public event EventHandler PdfGenerated;

public event EventHandler PdfGenerated;

Public Event PdfGenerated As EventHandler

Public Event PdfGenerated As EventHandler

Cette ligne déclare un champ d'événement nommé PdfGenerated. Elle utilise EventHandler, un délégué intégré avec la liste de paramètres suivante : (object sender, EventArgs e), souvent appelée le modèle de nommage pour les événements dans .NET.

Définir et s'abonner à des événements en C#

Ajouter des Méthodes aux Événements en Utilisant des Délégués

Les événements C# supportent l'ajout de méthodes dynamiquement à l'exécution en utilisant la syntaxe +=. Voici comment :

pdfService.PdfGenerated += (s, e) =>
{
    Console.WriteLine("PDF was generated!");
};

pdfService.PdfGenerated += (s, e) =>
{
    Console.WriteLine("PDF was generated!");
};

AddHandler pdfService.PdfGenerated, Sub(s, e)
	Console.WriteLine("PDF was generated!")
End Sub

AddHandler pdfService.PdfGenerated, Sub(s, e)
	Console.WriteLine("PDF was generated!")
End Sub

Cette classe abonnée écoute pour l'événement PdfGenerated et exécute un appel de méthode quand il est déclenché.

Données d'Événement Personnalisées

Pour passer des données d'événement telles que le chemin d'accès du fichier généré, définissez une classe dérivée de EventArgs :

public class PdfGeneratedEventArgs : EventArgs
{
    public string FilePath { get; set; } // returned value
}

public class PdfGeneratedEventArgs : EventArgs
{
    public string FilePath { get; set; } // returned value
}

Public Class PdfGeneratedEventArgs
	Inherits EventArgs

	Public Property FilePath() As String ' -  returned value
End Class

Public Class PdfGeneratedEventArgs
	Inherits EventArgs

	Public Property FilePath() As String ' -  returned value
End Class

Redéfinissez ensuite l'événement à l'aide d'un type de délégué générique :

public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;

public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;

Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)

Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)

Cela vous donne des données structurées et typées de façon sécurisée lorsque l'événement est levé, rendant votre logique de réponse plus puissante.

Gestion de Multiples Événements

Vous pouvez définir plusieurs événements :

public event EventHandler PdfGenerationStarted;
public event EventHandler<PdfGeneratedEventArgs> PdfGenerationCompleted;

public event EventHandler PdfGenerationStarted;
public event EventHandler<PdfGeneratedEventArgs> PdfGenerationCompleted;

Public Event PdfGenerationStarted As EventHandler
Public Event PdfGenerationCompleted As EventHandler(Of PdfGeneratedEventArgs)

Public Event PdfGenerationStarted As EventHandler
Public Event PdfGenerationCompleted As EventHandler(Of PdfGeneratedEventArgs)

Chaque champ d'événement est géré par une classe abonnée, permettant des méthodes de gestion d'événements distinctes par étape. Cette séparation des préoccupations a du sens dans des flux de travail complexes.

Utilisation des Gestionnaires d'Événements avec IronPDF

Lors de la génération de gros PDF, il est judicieux d'exécuter IronPDF sur un thread en arrière-plan et de notifier l'interface utilisateur à la fin. Voici comment la conception orientée événements peut aider :

Utiliser un BackgroundWorker pour générer des PDF de manière asynchrone
Lever des événements lorsque chaque étape est terminée
Passer des données de résultat en utilisant des objets de données d'événement

Exemple de Code – Générer des PDF de Manière Asynchrone

L'exemple suivant est le code complet pour utiliser la gestion d'événements avec IronPDF :

using System;
using System.ComponentModel;
using IronPdf;
namespace IronPdfEventHandlerExample
{
    // 1. Define custom EventArgs to carry event data
    public class PdfGeneratedEventArgs : EventArgs
    {
        public string FilePath { get; set; }
    }
    // 2. Main class with event, BackgroundWorker, and logic
    public class PdfGenerator
    {
        // Declare the public event using EventHandler<t>
        public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;
        private readonly BackgroundWorker _worker;
        public PdfGenerator()
        {
            _worker = new BackgroundWorker();
            _worker.DoWork += OnDoWork;
            _worker.RunWorkerCompleted += OnRunWorkerCompleted;
        }
        // Start the async operation
        public void GenerateAsync(string html, string outputPath)
        {
            _worker.RunWorkerAsync(new Tuple<string, string>(html, outputPath));
        }
        // Perform PDF generation in background
        private void OnDoWork(object sender, DoWorkEventArgs e)
        {
            var (html, path) = (Tuple<string, string>)e.Argument;
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs(path);
            e.Result = path;
        }
        // Notify subscribers when the PDF is ready
        private void OnRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            var path = e.Result as string;
            PdfGenerated?.Invoke(this, new PdfGeneratedEventArgs { FilePath = path });
        }
    }
    // 3. Program to wire it all together
    class Program
    {
        public static void Main(string[] args)
        {
            var generator = new PdfGenerator();
            // Subscribe to the PdfGenerated event
            generator.PdfGenerated += OnPdfGenerated;
            Console.WriteLine("Generating PDF asynchronously...");
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf");
            Console.WriteLine("Press any key to exit after generation.");
            Console.ReadKey();
        }
        // Event handler for when the PDF is ready
        static void OnPdfGenerated(object sender, PdfGeneratedEventArgs e)
        {
            Console.WriteLine($"PDF generated at: {e.FilePath}");
        }
    }
}

using System;
using System.ComponentModel;
using IronPdf;
namespace IronPdfEventHandlerExample
{
    // 1. Define custom EventArgs to carry event data
    public class PdfGeneratedEventArgs : EventArgs
    {
        public string FilePath { get; set; }
    }
    // 2. Main class with event, BackgroundWorker, and logic
    public class PdfGenerator
    {
        // Declare the public event using EventHandler<t>
        public event EventHandler<PdfGeneratedEventArgs> PdfGenerated;
        private readonly BackgroundWorker _worker;
        public PdfGenerator()
        {
            _worker = new BackgroundWorker();
            _worker.DoWork += OnDoWork;
            _worker.RunWorkerCompleted += OnRunWorkerCompleted;
        }
        // Start the async operation
        public void GenerateAsync(string html, string outputPath)
        {
            _worker.RunWorkerAsync(new Tuple<string, string>(html, outputPath));
        }
        // Perform PDF generation in background
        private void OnDoWork(object sender, DoWorkEventArgs e)
        {
            var (html, path) = (Tuple<string, string>)e.Argument;
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs(path);
            e.Result = path;
        }
        // Notify subscribers when the PDF is ready
        private void OnRunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            var path = e.Result as string;
            PdfGenerated?.Invoke(this, new PdfGeneratedEventArgs { FilePath = path });
        }
    }
    // 3. Program to wire it all together
    class Program
    {
        public static void Main(string[] args)
        {
            var generator = new PdfGenerator();
            // Subscribe to the PdfGenerated event
            generator.PdfGenerated += OnPdfGenerated;
            Console.WriteLine("Generating PDF asynchronously...");
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf");
            Console.WriteLine("Press any key to exit after generation.");
            Console.ReadKey();
        }
        // Event handler for when the PDF is ready
        static void OnPdfGenerated(object sender, PdfGeneratedEventArgs e)
        {
            Console.WriteLine($"PDF generated at: {e.FilePath}");
        }
    }
}

Imports System
Imports System.ComponentModel
Imports IronPdf

Namespace IronPdfEventHandlerExample

    ' 1. Define custom EventArgs to carry event data
    Public Class PdfGeneratedEventArgs
        Inherits EventArgs

        Public Property FilePath As String
    End Class

    ' 2. Main class with event, BackgroundWorker, and logic
    Public Class PdfGenerator

        ' Declare the public event using EventHandler(Of T)
        Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)
        Private ReadOnly _worker As BackgroundWorker

        Public Sub New()
            _worker = New BackgroundWorker()
            AddHandler _worker.DoWork, AddressOf OnDoWork
            AddHandler _worker.RunWorkerCompleted, AddressOf OnRunWorkerCompleted
        End Sub

        ' Start the async operation
        Public Sub GenerateAsync(html As String, outputPath As String)
            _worker.RunWorkerAsync(Tuple.Create(html, outputPath))
        End Sub

        ' Perform PDF generation in background
        Private Sub OnDoWork(sender As Object, e As DoWorkEventArgs)
            Dim args = DirectCast(e.Argument, Tuple(Of String, String))
            Dim html = args.Item1
            Dim path = args.Item2
            Dim renderer = New HtmlToPdf()
            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs(path)
            e.Result = path
        End Sub

        ' Notify subscribers when the PDF is ready
        Private Sub OnRunWorkerCompleted(sender As Object, e As RunWorkerCompletedEventArgs)
            Dim path = TryCast(e.Result, String)
            RaiseEvent PdfGenerated(Me, New PdfGeneratedEventArgs With {.FilePath = path})
        End Sub
    End Class

    ' 3. Program to wire it all together
    Module Program

        Sub Main(args As String())
            Dim generator = New PdfGenerator()
            ' Subscribe to the PdfGenerated event
            AddHandler generator.PdfGenerated, AddressOf OnPdfGenerated
            Console.WriteLine("Generating PDF asynchronously...")
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf")
            Console.WriteLine("Press any key to exit after generation.")
            Console.ReadKey()
        End Sub

        ' Event handler for when the PDF is ready
        Private Sub OnPdfGenerated(sender As Object, e As PdfGeneratedEventArgs)
            Console.WriteLine($"PDF generated at: {e.FilePath}")
        End Sub
    End Module

End Namespace

Imports System
Imports System.ComponentModel
Imports IronPdf

Namespace IronPdfEventHandlerExample

    ' 1. Define custom EventArgs to carry event data
    Public Class PdfGeneratedEventArgs
        Inherits EventArgs

        Public Property FilePath As String
    End Class

    ' 2. Main class with event, BackgroundWorker, and logic
    Public Class PdfGenerator

        ' Declare the public event using EventHandler(Of T)
        Public Event PdfGenerated As EventHandler(Of PdfGeneratedEventArgs)
        Private ReadOnly _worker As BackgroundWorker

        Public Sub New()
            _worker = New BackgroundWorker()
            AddHandler _worker.DoWork, AddressOf OnDoWork
            AddHandler _worker.RunWorkerCompleted, AddressOf OnRunWorkerCompleted
        End Sub

        ' Start the async operation
        Public Sub GenerateAsync(html As String, outputPath As String)
            _worker.RunWorkerAsync(Tuple.Create(html, outputPath))
        End Sub

        ' Perform PDF generation in background
        Private Sub OnDoWork(sender As Object, e As DoWorkEventArgs)
            Dim args = DirectCast(e.Argument, Tuple(Of String, String))
            Dim html = args.Item1
            Dim path = args.Item2
            Dim renderer = New HtmlToPdf()
            Dim pdf = renderer.RenderHtmlAsPdf(html)
            pdf.SaveAs(path)
            e.Result = path
        End Sub

        ' Notify subscribers when the PDF is ready
        Private Sub OnRunWorkerCompleted(sender As Object, e As RunWorkerCompletedEventArgs)
            Dim path = TryCast(e.Result, String)
            RaiseEvent PdfGenerated(Me, New PdfGeneratedEventArgs With {.FilePath = path})
        End Sub
    End Class

    ' 3. Program to wire it all together
    Module Program

        Sub Main(args As String())
            Dim generator = New PdfGenerator()
            ' Subscribe to the PdfGenerated event
            AddHandler generator.PdfGenerated, AddressOf OnPdfGenerated
            Console.WriteLine("Generating PDF asynchronously...")
            generator.GenerateAsync("<h1>Hello, IronPDF!</h1>", "output.pdf")
            Console.WriteLine("Press any key to exit after generation.")
            Console.ReadKey()
        End Sub

        ' Event handler for when the PDF is ready
        Private Sub OnPdfGenerated(sender As Object, e As PdfGeneratedEventArgs)
            Console.WriteLine($"PDF generated at: {e.FilePath}")
        End Sub
    End Module

End Namespace

Sortie console

Gestionnaire d'événements C# (Comment cela fonctionne pour les développeurs) : Figure 1 - Sortie de la console

Sortie PDF

Gestionnaire d'événements C# (Comment cela fonctionne pour les développeurs) : Figure 2 - Sortie PDF

Fonctionnalités Clés dans ce Code

public event EventHandler<PdfGeneratedEventArgs> : Déclare un événement fortement typé
PdfGeneratedEventArgs : Classe personnalisée pour les données d'événement
BackgroundWorker : Permet une exécution asynchrone pour éviter le blocage de l'interface utilisateur
?.Invoke(...) : Invocation sécurisée de l'événement
Tuple<string, string> : Passe le HTML et le chemin de sortie au thread d'arrière-plan

Conseils pour Travailler avec les Événements dans .NET

1. Éviter le Blocage du Thread UI

Utilisez des gestionnaires d'événements comme RunWorkerCompleted pour effectuer des mises à jour de l'interface utilisateur uniquement après la fin des tâches en arrière-plan.

2. Gérer les Exceptions de Manière Elégante

Enrobez votre logique de travail dans des blocs try-catch à l'intérieur de DoWork et passez les exceptions à RunWorkerCompleted via e.Error.

if (e.Error != null)
{
    MessageBox.Show("Error: " + e.Error.Message);
}

if (e.Error != null)
{
    MessageBox.Show("Error: " + e.Error.Message);
}

If e.Error IsNot Nothing Then
	MessageBox.Show("Error: " & e.Error.Message)
End If

If e.Error IsNot Nothing Then
	MessageBox.Show("Error: " & e.Error.Message)
End If

3. Se Désinscrire quand Nécessaire

Dans les applications de longue durée, désinscrivez-vous des événements lorsqu'ils ne sont plus nécessaires pour éviter les fuites de mémoire :

pdfWorker.DoWork -= PdfWorker_DoWork;

pdfWorker.DoWork -= PdfWorker_DoWork;

pdfWorker.DoWork -= PdfWorker_DoWork

pdfWorker.DoWork -= PdfWorker_DoWork

Conclusion

L'utilisation des gestionnaires d'événements, des types de délégués et des champs d'événements avec IronPDF ajoute une touche réactive et moderne aux applications .NET. Que vous génériez des documents dans une classe de base, créiez une logique réutilisable dans des classes dérivées, ou exploriez simplement le modèle d'événement de .NET, ce modèle est évolutif et propre.

Quand Utiliser Cette Approche

Vous voulez lever un événement lorsqu'une tâche est terminée
Vous avez besoin d'une séparation nette entre la logique et l'interface utilisateur
Vous travaillez avec BackgroundWorker, des événements et des délégués
Vous préférez les mécanismes de pointeur de fonction typé de C#

Alternatives à Explorer

async/await et Task.Run pour des flux de travail plus récents
IProgress<t> pour des mises à jour en temps réel pendant les longues opérations, IronPDF combiné avec des événements C# rend facile la création d'applications de génération de PDF puissantes et réactives, conçues pour une utilisation pratique. Prêt à mettre en œuvre la génération de PDF orientée événements dans votre application .NET ? Essayez-le avec la version d'essai gratuite d'IronPDF et gardez vos utilisateurs satisfaits grâce à des expériences fluides et sans blocage !

Jacob Mellor

Discutez maintenant avec l'équipe d'ingénierie

Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.

...