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");
Délégués C# (Comment ça marche pour les développeurs)
Regan Pun
février 18, 2024
Partager:
Dans la programmation C#, la compréhension des délégués est de la plus haute importance pour écrire un code flexible et extensible. Les délégués sont des entités puissantes qui facilitent la mise en œuvre de rappels, la gestion d'événements et les paradigmes de programmation fonctionnelle au sein du langage. Guide de Microsoft sur les délégués fournit une vue d'ensemble complète sur les instances de délégués à utiliser dans les applications C#.
Dans ce guide complet, nous allons nous plonger dans les complexités des délégués C#, en explorant leurs fonctionnalités, leurs cas d'utilisation et la façon dont ils permettent aux développeurs d'écrire un code plus modulaire et plus évolutif.
Comprendre les délégués en C# : L'épine dorsale des callbacks
À la base, un délégué en C# est un objet de type sûr, également appelé pointeur de fonction, qui encapsule une méthode ou plusieurs méthodes. Les délégués permettent de créer des références à des fonctions, ce qui permet de passer des méthodes en tant que paramètres, de les stocker dans des structures de données et de les invoquer de manière dynamique. Les délégués sont donc la pierre angulaire des mécanismes de rappel et de la mise en œuvre d'architectures axées sur les événements.
Principales caractéristiques des délégués C
Sécurité de type: Les délégués sont sûrs de type, garantissant que la signature de la méthode qu'ils référencent s'aligne sur la signature du délégué.
**Les délégués prennent en charge l'invocation multicast, ce qui permet de combiner plusieurs méthodes en une seule instance de délégué. Lorsqu'elles sont invoquées, toutes les méthodes du délégué de multidiffusion sont appelées séquentiellement.
Méthodes anonymes et expressions lambda: Les délégués C# s'intègrent de manière transparente aux méthodes anonymes et aux expressions lambda, en fournissant une syntaxe concise pour définir les corps des méthodes en ligne.
Utilisation et syntaxe de base
Les étapes fondamentales de l'utilisation des délégués comprennent la déclaration avec le type de délégué et les paramètres, l'instanciation et l'invocation en définissant les méthodes de rappel. Voici un exemple de base :
// Delegate declaration
public delegate void MyDelegate(string message);
// Instantiation
MyDelegate myDelegate = DisplayMessage;
// Method to be referenced
static void DisplayMessage(string message)
{
Console.WriteLine(message);
}
// Invocation
myDelegate("Hello, Delegates!");
// Delegate declaration
public delegate void MyDelegate(string message);
// Instantiation
MyDelegate myDelegate = DisplayMessage;
// Method to be referenced
static void DisplayMessage(string message)
{
Console.WriteLine(message);
}
// Invocation
myDelegate("Hello, Delegates!");
' Delegate declaration
Public Delegate Sub MyDelegate(ByVal message As String)
' Instantiation
Private myDelegate As MyDelegate = AddressOf DisplayMessage
' Method to be referenced
Shared Sub DisplayMessage(ByVal message As String)
Console.WriteLine(message)
End Sub
' Invocation
myDelegate("Hello, Delegates!")
$vbLabelText $csharpLabel
Scénarios de rappel : Exploiter les délégués pour plus de flexibilité
L'un des principaux cas d'utilisation des délégués est la mise en œuvre de rappels. Envisagez des scénarios dans lesquels une méthode doit notifier un composant externe lorsqu'un événement spécifique se produit. Les délégués offrent une solution propre et modulaire :
class Program
{
static void Main(string [] args)
{
public class EventPublisher
{
// Declare a delegate
public delegate void EventHandler(string eventName);
// Create an instance of the delegate
public 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}");
}
}
}
}
class Program
{
static void Main(string [] args)
{
public class EventPublisher
{
// Declare a delegate
public delegate void EventHandler(string eventName);
// Create an instance of the delegate
public 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}");
}
}
}
}
Friend Class Program
Shared Sub Main(ByVal args() As String)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' public class EventPublisher
' {
' ' Declare a delegate
' public delegate void EventHandler(string eventName);
' ' Create an instance of the delegate
' public EventHandler EventOccurred;
' ' Simulate an event
' public void SimulateEvent(string eventName)
' {
' ' Invoke the delegate to notify subscribers
' if (EventOccurred != Nothing)
' EventOccurred.Invoke(eventName);
' }
' }
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' 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(string.Format("Event handled: {0}", 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 dans l'adoption des concepts de 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, renvoyer des fonctions et créer un code plus expressif et plus concis :
public delegate int MyDelegate(int x, int y);
public class Calculator
{
public int PerformOperation(MyDelegate operation, int operand1, int operand2)
{
return operation(operand1, operand2);
}
}
// Usage
var calculator = new Calculator();
int result = calculator.PerformOperation((x, y) => x + y, 5, 3); // Adds 5 and 3
public delegate int MyDelegate(int x, int y);
public class Calculator
{
public int PerformOperation(MyDelegate operation, int operand1, int operand2)
{
return operation(operand1, operand2);
}
}
// Usage
var calculator = new Calculator();
int result = calculator.PerformOperation((x, y) => x + y, 5, 3); // Adds 5 and 3
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
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
$vbLabelText $csharpLabel
Présentation d'IronPDF : Un bref aperçu
En savoir plus sur les fonctionnalités d'IronPDF la bibliothèque PDF est une bibliothèque riche en fonctionnalités conçue pour faciliter la génération, la manipulation et l'interaction des PDF dans les applications C#. Que vous ayez besoin de créer des PDF à partir de zéro, de convertir du HTML en PDF ou d'extraire du contenu de PDF existants, IronPDF fournit un ensemble complet d'outils pour rationaliser ces tâches. Sa polyvalence en fait un atout précieux pour les développeurs qui travaillent sur un large éventail de projets.
Installation d'IronPDF : Un démarrage rapide
Pour commencer à exploiter la bibliothèque IronPDF dans votre projet C#, vous pouvez facilement installer le package NuGet IronPDF. Utilisez la commande suivante dans votre console de gestion des paquets :
Install-Package IronPdf
Vous pouvez également rechercher "IronPDF" dans le gestionnaire de paquets NuGet et l'installer à partir de là.
Délégués en C# : Un bref rappel
En C#, les délégués servent de pointeurs de fonction sûrs, 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 les différents scénarios mentionnés ci-dessus. La question se pose maintenant : Comment les délégués C# s'intègrent-ils dans l'environnement d'IronPDF et peuvent-ils être utilisés efficacement en tandem ?
Intégration des délégués à IronPDF
1. Utilisation de méthodes de rappel pour les événements de documents
L'une des façons d'exploiter les délégués avec IronPDF est de mettre en place des rappels pour les événements liés aux documents. IronPDF propose des événements auxquels vous pouvez vous abonner à l'aide de délégués, ce qui vous permet d'exécuter une logique personnalisée à des moments précis du processus de génération de documents. Par exemple :
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");
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");
public delegate string AddPasswordEventHandler(PdfDocument e);
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")
public delegate String AddPasswordEventHandler(PdfDocument e)
$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 renvoyer une chaîne. Dans cette méthode, une variable de type 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, la valeur "Iron123" est assignée à la variable password et renvoyée.
Ensuite, une instance 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, se voit attribuer la méthode AddPassword. Le délégué est alors invoqué avec la méthode Invoke, en passant l'instance document, et le mot de passe retourné est assigné à la propriété Password du document.
Enfin, la méthode SaveAs est appelée sur le document, l'enregistrant sous le nom de "PasswordProtected.pdf". Le code utilise effectivement un délégué pour déterminer et définir dynamiquement un mot de passe pour un PdfDocument en fonction de certaines conditions dans la méthode AddPassword.
2. Utilisation de 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 àgénérer des PDF à partir de HTMLet 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 pdfDocument = new ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf($"<html><body>{getDynamicContent()}</body></html>").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 pdfDocument = new ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf($"<html><body>{getDynamicContent()}</body></html>").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 pdfDocument = New ChromePdfRenderer()
pdfDocument.RenderHtmlAsPdf($"<html><body>{getDynamicContent()}</body></html>").SaveAs("DynamicContentDocument.pdf")
$vbLabelText $csharpLabel
Dans cet exemple, le délégué getDynamicContent génère dynamiquement du contenu HTML, qui est ensuite incorporé dans le document PDF.
Pour utiliser IronPDF de manière efficace et efficiente, veuillez consulter la pageDocumentation 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 possibilité de modifier par programme les appels de méthode. En tant qu'outil polyvalent de la boîte à outils C#, les délégués permettent aux développeurs de créer un code plus facile à maintenir, plus évolutif et plus expressif. Que vous construisiez des applications basées sur des événements, que vous mettiez en œuvre des mécanismes de rappel ou que vous 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. Qu'il s'agisse de personnaliser des événements de document ou d'injecter du contenu dynamique, les délégués constituent un mécanisme souple permettant d'étendre les fonctionnalités d'IronPDF. En explorant les possibilités, réfléchissez aux exigences spécifiques de votre projet et à la manière dont les délégués peuvent contribuer à un processus de génération de PDF plus adapté et plus dynamique avec IronPDF.
Regan est diplômé de l'université de Reading, où il a obtenu une licence en ingénierie électronique. Avant de rejoindre Iron Software, il s'était concentré sur une seule tâche. Ce qu'il apprécie le plus chez Iron Software, c'est la diversité des tâches qu'il peut accomplir, qu'il s'agisse d'apporter une valeur ajoutée aux ventes, à l'assistance technique, au développement de produits ou à la commercialisation. Il aime comprendre comment les développeurs utilisent la bibliothèque d'Iron Software et utiliser ces connaissances pour améliorer continuellement la documentation et développer les produits.
< PRÉCÉDENT Attributs C# (Comment cela fonctionne pour les développeurs)
SUIVANT > Opérateur ternaire C# (Comment il fonctionne pour les développeurs)
Des millions d'ingénieurs dans le monde entier lui font confiance
Réservez une démo en direct gratuite
Réservez une démonstration personnelle de 30 minutes.
Pas de contrat, pas de détails de carte, pas d'engagements.
Voici ce à quoi vous pouvez vous attendre :
Une démonstration en direct de notre produit et de ses principales fonctionnalités
Obtenez des recommandations de fonctionnalités spécifiques au projet
Toutes vos questions trouvent réponse pour vous assurer de disposer de toutes les informations dont vous avez besoin. (Aucun engagement de votre part.)
CHOISIR L'HEURE
VOS INFORMATIONS
Réservez votre démo en direct gratuite
Fiable par plus de 2 millions d'ingénieurs dans le monde entier