Dans ce tutoriel, nous allons enseigner les concepts de C# Action, Func delegate, et des sujets connexes. Ce guide est conçu pour les débutants et vous guidera à travers les bases, fournira des exemples et expliquera les termes clés de délégué d'action.

Commençons par comprendre ce que sont les délégués en C#. Nous explorerons la bibliothèque IronPDF plus tard dans l'article.

Comprendre les Délegués en C#

Les délégués sont une construction de programmation qui agit comme des références à des méthodes, définis par un ensemble particulier de paramètres et un type de retour, encapsulant des fonctionnalités comme le type de délégué prédéfini et permettant aux méthodes de retourner des valeurs.

Il permet de passer des méthodes comme arguments. Essentiellement, un délégué sert de pointeur de fonction, pointant vers la méthode qu'il représente. En C#, il existe deux types de délégués prédéfinis qui sont largement utilisés : Func et Action.

Qu'est-ce qu'un délégué Func ?

Le délégué Func représente une méthode qui peut avoir une valeur de retour. Le dernier paramètre de type spécifie le type de retour, et les types précédents spécifient les paramètres d'entrée.

Par exemple, un Func<int, int, string> prend deux paramètres entiers et retourne un message sous forme de chaîne.

Les délégués en pratique: Exemples

Jetons un coup d'œil à quelques exemples pour comprendre comment fonctionnent les délégués Func et Action en C#.

Exemple d'un délégué Action

Un délégué Action, un type de délégué prédéfini, est utilisé lorsque vous souhaitez exécuter une méthode qui ne retourne pas spécifiquement une valeur, en se concentrant sur les opérations. Voici un exemple de base:

Action<string> display = message => Console.WriteLine(message);
display("Hello, World!");

Action<string> display = message => Console.WriteLine(message);
display("Hello, World!");

Dim display As Action(Of String) = Sub(message) Console.WriteLine(message)
display("Hello, World!")

Dim display As Action(Of String) = Sub(message) Console.WriteLine(message)
display("Hello, World!")

Ce code définit un délégué Action, illustrant l'utilisation d'une méthode anonyme, qui prend un seul paramètre de chaîne et l'affiche dans la console. Le symbole => est utilisé pour définir une expression lambda, qui est un moyen concis d'écrire des méthodes anonymes.

Exemple d'un délégué Func

Un délégué Func, qui retourne une valeur, peut être utilisé comme suit :

Func<int, int, int> add = (x, y) => x + y;
int result = add(5, 3);
Console.WriteLine(result);

Func<int, int, int> add = (x, y) => x + y;
int result = add(5, 3);
Console.WriteLine(result);

Dim add As Func(Of Integer, Integer, Integer) = Function(x, y) x + y
Dim result As Integer = add(5, 3)
Console.WriteLine(result)

Dim add As Func(Of Integer, Integer, Integer) = Function(x, y) x + y
Dim result As Integer = add(5, 3)
Console.WriteLine(result)

Cet exemple crée un délégué Func qui prend deux paramètres entiers et retourne leur somme. La somme s'affichera dans la console comme suit :

Concepts Clés

Méthodes Anonymes

Les méthodes anonymes en C# offrent un moyen de définir des méthodes en ligne sans nom. Elles sont souvent utilisées avec des délégués pour créer des instances de délégués directement.

Expressions Lambda

Les expressions lambda sont une abréviation pour écrire des méthodes anonymes. Elles permettent d'écrire moins de code tout en obtenant le même résultat.

Délégué Générique

Un délégué générique peut fonctionner avec n'importe quel type de données. Func et Action sont des exemples de délégués génériques, offrant plus de flexibilité en vous permettant de spécifier des types d'entrée et de sortie à l'exécution.

Instance de Délégué

Une instance de délégué est créée avec le mot-clé new ou simplement en assignant une méthode qui correspond à la signature du délégué.

Espace de Noms System

L'espace de noms System dans .NET contient des types intégrés comme Func et Action, qui font partie de la bibliothèque de classes de base.

Programmation Asynchrone avec les Délégués

Les délégués, y compris Action et Func, sont essentiels pour gérer les tâches asynchrones en C#. Ils permettent aux développeurs d'encapsuler une référence à une méthode qui peut ensuite être exécutée de manière asynchrone. Cela signifie que le thread principal de l'application peut initier une tâche puis continuer avec d'autres travaux jusqu'à ce que la tâche soit terminée.

À ce moment-là, une méthode de rappel, référencée par un délégué, est appelée pour gérer le résultat. Ce modèle est essentiel pour créer des interfaces utilisateurs réactives qui restent interactives même en effectuant des opérations de longue durée.

Exemple : Traitement Asynchrone de Fichier

Considérez une application qui nécessite de traiter un grand fichier. L'utilisation d'un délégué Action en conjonction avec des modèles de programmation asynchrone comme Task peut améliorer considérablement les performances de l'application :

public async Task ProcessFileAsync(string filePath, Action<string> onComplete)
{
    // Asynchronously read file content
    string fileContent = await File.ReadAllTextAsync(filePath);
    // Process the file content here (omitted for brevity)
    
    // Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.");
}

public async Task ProcessFileAsync(string filePath, Action<string> onComplete)
{
    // Asynchronously read file content
    string fileContent = await File.ReadAllTextAsync(filePath);
    // Process the file content here (omitted for brevity)
    
    // Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.");
}

Public Async Function ProcessFileAsync(filePath As String, onComplete As Action(Of String)) As Task
    ' Asynchronously read file content
    Dim fileContent As String = Await File.ReadAllTextAsync(filePath)
    ' Process the file content here (omitted for brevity)

    ' Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.")
End Function

Public Async Function ProcessFileAsync(filePath As String, onComplete As Action(Of String)) As Task
    ' Asynchronously read file content
    Dim fileContent As String = Await File.ReadAllTextAsync(filePath)
    ' Process the file content here (omitted for brevity)

    ' Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.")
End Function

Dans cet exemple, File.ReadAllTextAsync est utilisé pour lire le contenu du fichier sans bloquer le thread principal. Une fois le fichier traité, un délégué Action nommé onComplete est invoqué pour informer l'appelant que l'opération est terminée, permettant d'autres actions comme la mise à jour de l'interface utilisateur ou la consignation des résultats.

Introduction de IronPDF : Une bibliothèque PDF pour C#

IronPDF est une bibliothèque PDF C# complète conçue pour les développeurs .NET pour créer, éditer et manipuler des fichiers PDF avec facilité. Elle se distingue par un moteur de rendu basé sur Chrome, garantissant des PDF parfaits au pixel près à partir de contenu HTML, CSS, JavaScript et images.

IronPDF est compatible avec un large éventail de frameworks et environnements .NET, y compris .NET Standard, .NET Framework et .NET Core, sur les plateformes Windows, Linux et macOS.

Installer IronPDF

Pour intégrer IronPDF dans vos projets .NET, vous pouvez utiliser NuGet, qui est la méthode la plus simple. Il suffit d'ouvrir la Console du Package Manager dans Visual Studio et d'exécuter la commande suivante :

Install-Package IronPdf

Cette commande récupère et installe le package IronPDF, configurant votre projet pour commencer à utiliser IronPDF pour la génération et la manipulation de PDF.

Exemple de Code avec un Délégué Action

Voici un exemple simple démontrant comment utiliser IronPDF en conjonction avec un délégué Action pour effectuer une tâche de génération de PDF :

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        // Define an Action delegate that takes HTML content as a string
        Action<string> generatePdf = html =>
        {
            // Render the HTML as a PDF
            var pdf = renderer.RenderHtmlAsPdf(html);
            
            // Save the PDF to a file
            pdf.SaveAs("example.pdf");
        };
        
        // Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        // Define an Action delegate that takes HTML content as a string
        Action<string> generatePdf = html =>
        {
            // Render the HTML as a PDF
            var pdf = renderer.RenderHtmlAsPdf(html);
            
            // Save the PDF to a file
            pdf.SaveAs("example.pdf");
        };
        
        // Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports IronPdf
Imports System

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' Define an Action delegate that takes HTML content as a string
        Dim generatePdf As Action(Of String) = Sub(html)
                                                   ' Render the HTML as a PDF
                                                   Dim pdf = renderer.RenderHtmlAsPdf(html)

                                                   ' Save the PDF to a file
                                                   pdf.SaveAs("example.pdf")
                                               End Sub

        ' Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>")
        Console.WriteLine("PDF generated successfully.")
    End Sub
End Module

Imports IronPdf
Imports System

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        ' Define an Action delegate that takes HTML content as a string
        Dim generatePdf As Action(Of String) = Sub(html)
                                                   ' Render the HTML as a PDF
                                                   Dim pdf = renderer.RenderHtmlAsPdf(html)

                                                   ' Save the PDF to a file
                                                   pdf.SaveAs("example.pdf")
                                               End Sub

        ' Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>")
        Console.WriteLine("PDF generated successfully.")
    End Sub
End Module

Cet exemple définit un délégué Action qui prend une chaîne HTML et utilise IronPDF pour la convertir en document PDF. Le PDF généré est ensuite enregistré dans le système de fichiers. Cette approche démontre comment les délégués peuvent être utilisés pour encapsuler une logique de génération de PDF, rendant votre code plus modulaire et flexible.

Licences

IronPDF propose diverses options de licence pour les développeurs, allant des licences pour développeurs individuels aux accords d'entreprise. Les prix pour ces licences commencent à partir de $999.

Conclusion

D'ici là, vous devriez avoir une compréhension de base des délégués Action et Func en C#, ainsi que de la façon d'utiliser les méthodes anonymes et les expressions lambda. N'oubliez pas, la pratique est la clé pour maîtriser les concepts de délégués. Essayez de créer vos propres exemples pour définir, affecter et invoquer des délégués.

Vous pouvez explorer librement les capacités de IronPDF avec sa version d'essai gratuite. Si cela convient aux exigences de votre projet, vous pouvez obtenir une licence avec des prix débutant à $999.