Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. guide-des-délégués-csharp
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

Dans la programmation C#, comprendre les délégués est d'une importance capitale pour écrire un code flexible et extensible. Les délégués servent d'entités puissantes qui facilitent la mise en œuvre des rappels, la gestion des événements et les paradigmes de programmation fonctionnelle au sein du langage. Le guide de Microsoft sur les délégués fournit un aperçu complet des instances de délégués à utiliser dans les applications C#.

Dans ce guide complet, nous approfondirons les complexités des délégués C#, en explorant leur fonctionnalité, leurs cas d'utilisation et comment ils permettent aux développeurs d'écrire un code plus modulaire et évolutif.

Comprendre les délégués C#: L'épine dorsale des rappels

Dans son essence, un délégué en C# est un objet sûr de type, également appelé pointeur de fonction, qui encapsule une méthode ou plus d'une méthode. Les délégués permettent de créer des références à des fonctions, offrant un moyen de passer des méthodes en tant que paramètres, de les stocker dans des structures de données et de les invoquer dynamiquement. Cela fait des délégués la pierre angulaire pour réaliser des mécanismes de rappel et implémenter des architectures axées sur les événements.

Caractéristiques clés des délégués C

  1. Sécurité de type : Les délégués sont sûrs de type, assurant que la signature de la méthode qu'ils référencent s'aligne avec la signature du délégué.
  2. Multicast : Les délégués prennent en charge l'invocation multicast, permettant à plusieurs méthodes d'être combinées en une seule instance de délégué. Lorsqu'ils sont invoqués, toutes les méthodes dans le délégué multicast sont appelées séquentiellement.
  3. Méthodes anonymes et expressions lambda : Les délégués C# s'intègrent parfaitement avec les méthodes anonymes et les expressions lambda, offrant une syntaxe concise pour définir les corps de méthode en ligne.

Utilisation de base et syntaxe

Les étapes fondamentales pour utiliser les délégués impliquent la déclaration avec le type de délégué et les paramètres, l'instanciation, et l'invocation en définissant des méthodes de rappel. Voici un exemple de base:

// Delegate declaration
public delegate void MyDelegate(string message);

class Program
{
    static void Main(string[] args)
    {
        // Instantiation
        MyDelegate myDelegate = DisplayMessage;

        // Invocation
        myDelegate("Hello, Delegates!");
    }

    // Method to be referenced
    static void DisplayMessage(string message)
    {
        Console.WriteLine(message);
    }
}
// Delegate declaration
public delegate void MyDelegate(string message);

class Program
{
    static void Main(string[] args)
    {
        // Instantiation
        MyDelegate myDelegate = DisplayMessage;

        // Invocation
        myDelegate("Hello, Delegates!");
    }

    // Method to be referenced
    static void DisplayMessage(string message)
    {
        Console.WriteLine(message);
    }
}
' Delegate declaration
Public Delegate Sub MyDelegate(ByVal message As String)

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Instantiation
		Dim myDelegate As MyDelegate = AddressOf DisplayMessage

		' Invocation
		myDelegate("Hello, Delegates!")
	End Sub

	' Method to be referenced
	Private Shared Sub DisplayMessage(ByVal message As String)
		Console.WriteLine(message)
	End Sub
End Class
$vbLabelText   $csharpLabel

Scénarios de rappel : Tirer avantage des délégués pour la flexibilité

L'un des principaux cas d'utilisation des délégués est la mise en œuvre des rappels. Considérez des scénarios où une méthode doit notifier un composant externe lorsque un événement spécifique se produit. Les délégués offrent une solution propre et modulaire :

using System;

class Program
{
    static void Main(string[] args)
    {
        EventPublisher publisher = new EventPublisher();
        EventSubscriber subscriber = new EventSubscriber(publisher);

        publisher.SimulateEvent("Test Event");
    }
}

public class EventPublisher
{
    // Declare a delegate type
    public delegate void EventHandler(string eventName);

    // Create an instance of the delegate
    public event EventHandler EventOccurred;

    // Simulate an event
    public void SimulateEvent(string eventName)
    {
        // Invoke the delegate to notify subscribers
        EventOccurred?.Invoke(eventName);
    }
}

public class EventSubscriber
{
    public EventSubscriber(EventPublisher eventPublisher)
    {
        // Subscribe to the event using the delegate
        eventPublisher.EventOccurred += HandleEvent;
    }

    // Method to be invoked when the event occurs
    private void HandleEvent(string eventName)
    {
        Console.WriteLine($"Event handled: {eventName}");
    }
}
using System;

class Program
{
    static void Main(string[] args)
    {
        EventPublisher publisher = new EventPublisher();
        EventSubscriber subscriber = new EventSubscriber(publisher);

        publisher.SimulateEvent("Test Event");
    }
}

public class EventPublisher
{
    // Declare a delegate type
    public delegate void EventHandler(string eventName);

    // Create an instance of the delegate
    public event EventHandler EventOccurred;

    // Simulate an event
    public void SimulateEvent(string eventName)
    {
        // Invoke the delegate to notify subscribers
        EventOccurred?.Invoke(eventName);
    }
}

public class EventSubscriber
{
    public EventSubscriber(EventPublisher eventPublisher)
    {
        // Subscribe to the event using the delegate
        eventPublisher.EventOccurred += HandleEvent;
    }

    // Method to be invoked when the event occurs
    private void HandleEvent(string eventName)
    {
        Console.WriteLine($"Event handled: {eventName}");
    }
}
Imports System

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim publisher As New EventPublisher()
		Dim subscriber As New EventSubscriber(publisher)

		publisher.SimulateEvent("Test Event")
	End Sub
End Class

Public Class EventPublisher
	' Declare a delegate type
	Public Delegate Sub EventHandler(ByVal eventName As String)

	' Create an instance of the delegate
	Public Event EventOccurred As EventHandler

	' Simulate an event
	Public Sub SimulateEvent(ByVal eventName As String)
		' Invoke the delegate to notify subscribers
		RaiseEvent EventOccurred(eventName)
	End Sub
End Class

Public Class EventSubscriber
	Public Sub New(ByVal eventPublisher As EventPublisher)
		' Subscribe to the event using the delegate
		AddHandler eventPublisher.EventOccurred, AddressOf HandleEvent
	End Sub

	' Method to be invoked when the event occurs
	Private Sub HandleEvent(ByVal eventName As String)
		Console.WriteLine($"Event handled: {eventName}")
	End Sub
End Class
$vbLabelText   $csharpLabel

Programmation fonctionnelle avec des délégués

Les délégués jouent un rôle crucial pour adopter les concepts de la programmation fonctionnelle en C#. En utilisant des délégués avec des fonctions d'ordre supérieur, les développeurs peuvent passer des fonctions comme arguments, retourner des fonctions, et créer un code plus expressif et concis :

public delegate int MyDelegate(int x, int y);

public class Calculator
{
    public int PerformOperation(MyDelegate operation, int operand1, int operand2)
    {
        // Execute the operation method reference through the passed delegate
        return operation(operand1, operand2);
    }
}

// Usage
var calculator = new Calculator();
int result = calculator.PerformOperation((x, y) => x + y, 5, 3); // Adds 5 and 3
Console.WriteLine(result); // Outputs: 8
public delegate int MyDelegate(int x, int y);

public class Calculator
{
    public int PerformOperation(MyDelegate operation, int operand1, int operand2)
    {
        // Execute the operation method reference through the passed delegate
        return operation(operand1, operand2);
    }
}

// Usage
var calculator = new Calculator();
int result = calculator.PerformOperation((x, y) => x + y, 5, 3); // Adds 5 and 3
Console.WriteLine(result); // Outputs: 8
Public Delegate Function MyDelegate(ByVal x As Integer, ByVal y As Integer) As Integer

Public Class Calculator
	Public Function PerformOperation(ByVal operation As MyDelegate, ByVal operand1 As Integer, ByVal operand2 As Integer) As Integer
		' Execute the operation method reference through the passed delegate
		Return operation(operand1, operand2)
	End Function
End Class

' Usage
Private calculator = New Calculator()
Private result As Integer = calculator.PerformOperation(Function(x, y) x + y, 5, 3) ' Adds 5 and 3
Console.WriteLine(result) ' Outputs: 8
$vbLabelText   $csharpLabel

Présentation d'IronPDF : Un aperçu

Délegués C# (Comment cela fonctionne pour les développeurs) : Figure 1 - Page web IronPDF

En savoir plus sur les fonctionnalités d'IronPDF en tant que bibliothèque riche en fonctionnalités conçue pour faciliter la génération, la manipulation et l'interaction de PDF dans les applications C#. Que vous ayez besoin de créer des PDFs à partir de zéro, de convertir des HTML en PDF, ou d'extraire le contenu de PDFs existants, IronPDF fournit un ensemble complet d'outils pour simplifier ces tâches. Sa polyvalence en fait un atout précieux pour les développeurs travaillant sur un large éventail de projets.

Installer IronPDF : Un démarrage rapide

Pour commencer à utiliser la bibliothèque IronPDF dans votre projet C#, vous pouvez facilement installer le package NuGet IronPDF. Utilisez la commande suivante dans votre Console du Gestionnaire de Packages :

Install-Package IronPdf

Alternativement, vous pouvez rechercher "IronPDF" dans le gestionnaire de packages NuGet et l'installer à partir de là.

Délegués C# (Comment cela fonctionne pour les développeurs) : Figure 2 - Installation de la bibliothèque IronPDF via le Gestionnaire de Paquets NuGet

Les délégués en C#: Un rapide récapitulatif

En C#, les délégués servent de pointeurs de fonction sûrs de type, permettant aux méthodes d'être référencées et transmises en tant que paramètres. Les délégués jouent un rôle crucial dans différents scénarios comme mentionné ci-dessus. Maintenant, la question se pose : Comment les délégués C# s'intègrent-ils dans l'environnement d'IronPDF, et peuvent-ils être utilisés efficacement de concert ?

Intégration des délégués avec IronPDF

1. Utiliser des méthodes de rappel pour les événements de document

Un moyen de tirer parti des délégués avec IronPDF est à travers des rappels pour les événements de document. IronPDF fournit des événements auxquels vous pouvez vous abonner en utilisant des délégués, vous permettant d'exécuter une logique personnalisée à des moments spécifiques pendant le processus de génération de document. Par exemple :

using IronPdf;

public delegate string AddPasswordEventHandler(PdfDocument e);

string AddPassword(PdfDocument document)
{
    string password = "";
    if (document.Password == "")
    {
        password = "Iron123";
    }
    return password;
}

PdfDocument document = new PdfDocument("StyledDocument.pdf");
AddPasswordEventHandler handler = AddPassword;
document.Password = handler.Invoke(document); // Subscribe to the event
document.SaveAs("PasswordProtected.pdf");
using IronPdf;

public delegate string AddPasswordEventHandler(PdfDocument e);

string AddPassword(PdfDocument document)
{
    string password = "";
    if (document.Password == "")
    {
        password = "Iron123";
    }
    return password;
}

PdfDocument document = new PdfDocument("StyledDocument.pdf");
AddPasswordEventHandler handler = AddPassword;
document.Password = handler.Invoke(document); // Subscribe to the event
document.SaveAs("PasswordProtected.pdf");
Imports IronPdf

Public Delegate Function AddPasswordEventHandler(ByVal e As PdfDocument) As String

Private Function AddPassword(ByVal document As PdfDocument) As String
	Dim password As String = ""
	If document.Password = "" Then
		password = "Iron123"
	End If
	Return password
End Function

Private document As New PdfDocument("StyledDocument.pdf")
Private handler As AddPasswordEventHandler = AddressOf AddPassword
document.Password = handler.Invoke(document) ' Subscribe to the event
document.SaveAs("PasswordProtected.pdf")
$vbLabelText   $csharpLabel

Dans cet extrait de code C#, une méthode nommée AddPassword est définie pour accepter un PdfDocument comme paramètre et retourner une chaîne. Dans cette méthode, une variable de chaîne nommée password est initialisée, et une vérification conditionnelle est effectuée sur la propriété Password du PdfDocument fourni. Si le mot de passe est une chaîne vide, attribuez la valeur "Iron123" à la variable password, et retournez-la.

Ensuite, une instance de PdfDocument est créée avec le nom de fichier "StyledDocument.pdf". Un délégué nommé AddPasswordEventHandler est déclaré avec la même signature que la méthode AddPassword. Une instance de ce délégué, nommée handler, est attribuée à la méthode AddPassword. Le délégué est ensuite invoqué avec la méthode Invoke, en passant l'instance document, et le mot de passe retourné est attribué à la propriété Password du document.

Enfin, la méthode SaveAs est appelée sur le document, le sauvegardant sous le nom "PasswordProtected.pdf". Le code utilise efficacement un délégué pour déterminer dynamiquement et définir un mot de passe pour un PdfDocument basé sur certaines conditions au sein de la méthode AddPassword.

2. Utiliser des délégués pour le contenu dynamique

Les délégués peuvent également être utilisés pour injecter du contenu dynamique dans le document PDF. IronPDF prend en charge l'insertion de contenu HTML pour générer des PDF à partir de HTML, et les développeurs peuvent utiliser des délégués pour générer dynamiquement du HTML en fonction de certaines conditions ou données :

// Assuming GetDynamicContent is a delegate that generates dynamic HTML content
Func<string> getDynamicContent = () =>
{
    // Custom logic to generate dynamic content
    return "<p>This is dynamic content based on some condition.</p>";
};

// Incorporate dynamic HTML into the PDF
var pdfRenderer = new ChromePdfRenderer();
var pdfDocument = pdfRenderer.RenderHtmlAsPdf($"<html><body>{getDynamicContent()}</body></html>");
pdfDocument.SaveAs("DynamicContentDocument.pdf");
// Assuming GetDynamicContent is a delegate that generates dynamic HTML content
Func<string> getDynamicContent = () =>
{
    // Custom logic to generate dynamic content
    return "<p>This is dynamic content based on some condition.</p>";
};

// Incorporate dynamic HTML into the PDF
var pdfRenderer = new ChromePdfRenderer();
var pdfDocument = pdfRenderer.RenderHtmlAsPdf($"<html><body>{getDynamicContent()}</body></html>");
pdfDocument.SaveAs("DynamicContentDocument.pdf");
' Assuming GetDynamicContent is a delegate that generates dynamic HTML content
Dim getDynamicContent As Func(Of String) = Function()
	' Custom logic to generate dynamic content
	Return "<p>This is dynamic content based on some condition.</p>"
End Function

' Incorporate dynamic HTML into the PDF
Dim pdfRenderer = New ChromePdfRenderer()
Dim pdfDocument = pdfRenderer.RenderHtmlAsPdf($"<html><body>{getDynamicContent()}</body></html>")
pdfDocument.SaveAs("DynamicContentDocument.pdf")
$vbLabelText   $csharpLabel

Dans cet exemple, le délégué getDynamicContent génère du contenu HTML dynamiquement, qui est ensuite intégré dans le document PDF.

Délegués C# (Comment cela fonctionne pour les développeurs) : Figure 3 - PDF généré par le code précédent

Pour utiliser IronPDF de manière efficace et efficiente, veuillez visiter la documentation IronPDF.

Conclusion

En conclusion, les délégués C# sont une pierre angulaire de la flexibilité et de la modularité du code. Ils permettent aux développeurs de mettre en œuvre des rappels, de gérer des événements, et d'adopter des paradigmes de programmation fonctionnelle tels que la capacité de modifier programatiquement les appels de méthode. En tant qu'outil polyvalent dans la boîte à outils C#, les délégués permettent aux développeurs de créer un code plus maintenable, évolutif et expressif. Que vous construisiez des applications axées sur les événements, implémentiez des mécanismes de rappel, ou exploriez la programmation fonctionnelle, les délégués C# sont un allié puissant dans votre parcours de programmation.

Les délégués C# et IronPDF peuvent former un duo coopératif, améliorant les capacités de génération de documents dans vos applications. Que vous personnalisiez les événements de document ou injectiez du contenu dynamique, les délégués fournissent un mécanisme flexible pour étendre la fonctionnalité d'IronPDF. Au fur et à mesure de votre exploration des possibilités, considérez les exigences spécifiques de votre projet et comment les délégués peuvent contribuer à un processus de génération de PDF plus adapté et dynamique avec IronPDF.

IronPDF offre un essai gratuit pour tester ses fonctionnalités complètes. Il peut être licencié pour une utilisation commerciale à partir de $799.

Questions Fréquemment Posées

Que sont les délégués C# et pourquoi sont-ils importants?

Les délégués C# sont des pointeurs de méthode types-sécurisés, permettant aux méthodes d'être passées en tant que paramètres et invoquées dynamiquement. Ils sont cruciaux pour écrire du code flexible, modulaire et évolutif, facilitant la gestion des événements, les rappels et les paradigmes de programmation fonctionnelle.

Comment les délégués peuvent-ils être utilisés pour la génération de PDF en C#?

Les délégués peuvent être utilisés pour améliorer la génération de PDF en activant les rappels pour les événements de document et en injectant du contenu dynamique dans les PDFs. Par exemple, les délégués peuvent s'abonner aux événements de document ou faciliter la génération de contenu HTML dynamique dans les PDFs à l'aide de IronPDF.

Quel est le rôle des délégués dans la programmation événementielle en C#?

Dans la programmation événementielle, les délégués permettent de créer des gestionnaires d'événements pouvant répondre à des événements spécifiques, activant un mécanisme de rappel propre et modulaire pour notifier les composants externes lorsque des événements se produisent.

Comment fonctionnent les délégués multicast en C#?

Les délégués multicast en C# permettent à plusieurs méthodes d'être combinées en une seule instance de délégué. Cela permet l'invocation séquentielle de toutes les méthodes dans le délégué, facilitant des scénarios complexes de gestion d'événements.

Les délégués C# peuvent-ils être utilisés avec les expressions lambda?

Oui, les délégués C# peuvent être utilisés avec les expressions lambda, offrant un moyen concis de définir les corps de méthode en ligne. Cela améliore la lisibilité et la flexibilité du code, permettant une assignation facile des méthodes aux délégués.

Comment déclare-t-on et utilise-t-on un délégué en C#?

Pour utiliser un délégué en C#, déclarez un type de délégué, instanciez-le avec une référence de méthode, et invoquez-le pour exécuter les méthodes référencées. Ce processus permet une invocation de méthode flexible et une exécution dynamique du code.

Comment les développeurs peuvent-ils intégrer des bibliothèques PDF dans leurs projets C# pour la génération de documents?

Les développeurs peuvent intégrer des bibliothèques PDF en installant le package NuGet approprié via la Console du Package Manager ou via le NuGet Package Manager. Les bibliothèques comme IronPDF offrent des solutions robustes pour la génération et la manipulation des PDFs.

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. Démarrer l'essai gratuit