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.
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.
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 Sub MyDelegate(message As String)
Class Program
Shared Sub Main(args As String())
' Instantiation
Dim myDelegate As MyDelegate = AddressOf DisplayMessage
' Invocation
myDelegate("Hello, Delegates!")
End Sub
' Method to be referenced
Shared Sub DisplayMessage(message As String)
Console.WriteLine(message)
End Sub
End ClassL'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}");
}
}Imports System
Module Program
Sub Main(args As String())
Dim publisher As New EventPublisher()
Dim subscriber As New EventSubscriber(publisher)
publisher.SimulateEvent("Test Event")
End Sub
End Module
Public Class EventPublisher
' Declare a delegate type
Public Delegate Sub EventHandler(eventName As String)
' Create an instance of the delegate
Public Event EventOccurred As EventHandler
' Simulate an event
Public Sub SimulateEvent(eventName As String)
' Invoke the delegate to notify subscribers
RaiseEvent EventOccurred(eventName)
End Sub
End Class
Public Class EventSubscriber
Public Sub New(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(eventName As String)
Console.WriteLine($"Event handled: {eventName}")
End Sub
End ClassLes 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: 8Public 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
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.
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 :
Alternativement, vous pouvez rechercher "IronPDF" dans le gestionnaire de packages NuGet et l'installer à partir de là.
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 ?
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");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")Dans ce snippet 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 de l'PdfDocument fourni. Si le mot de passe est une chaîne vide, assignez 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 assignée à la méthode AddPassword. Le délégué est ensuite invoqué avec la méthode Invoke, passant l'instance document, et le mot de passe retourné est assigné à la propriété Password de l'document.
Enfin, la méthode SaveAs est appelée sur l'document, l'enregistrant sous "PasswordProtected.pdf". Le code utilise efficacement un délégué pour déterminer et définir dynamiquement un mot de passe pour un PdfDocument basé sur certaines conditions dans la méthode AddPassword.
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
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")Dans cet exemple, le délégué getDynamicContent génère du contenu HTML dynamiquement, qui est ensuite intégré dans le document PDF.
Pour utiliser IronPDF de manière efficace et efficiente, veuillez visiter la documentation IronPDF.
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 un usage commercial à partir de $999.
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.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
