Action C# (Comment ça marche pour les développeurs)

Dans ce tutoriel, nous allons enseigner les concepts d'action C#, de délégué Func, 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 dedélégué à l'action.

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

Comprendre les délégués dans C# ;

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

Il permet de passer des méthodes en tant qu'arguments. Essentiellement, un délégué sert de pointeur de fonction, indiquant 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 renvoie un message sous forme de chaîne.

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

Prenons quelques exemples pour comprendre le fonctionnement des délégués Func et Action en C#.

Exemple de délégué à l'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 renvoie pas spécifiquement une valeur, mais qui se concentre plutôt sur des 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!")

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

Exemple de délégué Func

Un délégué Func, qui renvoie 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)

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

Concepts clés

Méthodes anonymes

Les méthodes anonymes en C# permettent de définir des méthodes inline sans nom. Ils sont souvent utilisés avec les délégués pour créer directement des instances de délégués.

Expressions lambda

Les expressions lambda sont un raccourci pour écrire des méthodes anonymes. Ils 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 travailler avec n'importe quel type de données. Func et Action sont des exemples de délégués génériques, qui offrent plus de flexibilité en permettant de spécifier les types d'entrée et de sortie au moment de l'exécution.

Instance déléguée

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

Espace de noms du système

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

Programmation asynchrone avec des délégués

Les délégués, y compris Action et Func, font partie intégrante de la gestion des 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 lancer une tâche et poursuivre d'autres travaux jusqu'à ce que la tâche soit terminée.

À ce stade, une méthode de rappel, référencée par un délégué, est appelée pour traiter le résultat. Ce modèle est essentiel pour créer des interfaces utilisateur réactives qui restent interactives même lors d'opérations de longue durée.

Exemple : Traitement asynchrone des fichiers

Prenons l'exemple d'une application qui doit traiter un fichier volumineux. L'utilisation d'un délégué Action en conjonction avec des modèles de programmation asynchrones tels que Task peut améliorer de manière significative 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(ByVal filePath As String, ByVal 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
	If onComplete IsNot Nothing Then
		onComplete.Invoke("File processing completed successfully.")
	End If
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 notifier à l'appelant que l'opération est terminée, ce qui permet d'autres actions telles que la mise à jour de l'interface utilisateur ou l'enregistrement des résultats.

Introduction d'IronPDF : Une bibliothèque PDF en C

IronPDF est une bibliothèque PDF C# complète conçue pour les développeurs .NET afin de créer, d'éditer et de manipuler des fichiers PDF en toute simplicité. Il se distingue par un moteur de rendu basé sur Chrome, ce qui garantitdes PDF parfaits au pixel près à partir d'un contenu HTML, CSS, JavaScript et images.

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

Installation d'IronPDF

Pour incorporer IronPDF for .NET dans vos projets .NET, vous pouvez utiliser NuGet, ce qui est la méthode la plus simple. Il suffit d'ouvrir la console du gestionnaire de paquets dans Visual Studio et d'exécuter la commande suivante :

Install-Package IronPdf

Cette commande récupère et installe le paquetage 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é d'action

Voici un exemple simple démontrant comment utiliser IronPDF en conjonction avec un délégué d'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();
        Action<string> generatePdf = html =>
        {
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs("example.pdf");
        };
        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();
        Action<string> generatePdf = html =>
        {
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs("example.pdf");
        };
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports IronPdf
Imports System
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		Dim generatePdf As Action(Of String) = Sub(html)
			Dim pdf = renderer.RenderHtmlAsPdf(html)
			pdf.SaveAs("example.pdf")
		End Sub
		generatePdf("<p>Hello, world!</p>")
		Console.WriteLine("PDF generated successfully.")
	End Sub
End Class

Cet exemple définit un délégué d'action qui prend une chaîne de caractères HTML et utilise IronPDF pour la transformer en document PDF.

Le PDF généré est ensuite enregistré dans le système de fichiers. Cette approche montre comment les délégués peuvent être utilisés pour encapsuler la logique de génération de PDF, ce qui rend votre code plus modulaire et plus flexible.

Licences

IronPDF propose différentsoptions de licence pour les développeursles licences d'utilisation des produits de l'Union européenne sont nombreuses, depuis les licences individuelles de développeurs jusqu'aux accords d'entreprise. Le prix de ces licences commence à partir de $749.

Conclusion

À ce stade, vous devriez avoir une compréhension de base des délégués Action et Func en C#, ainsi que de l'utilisation des méthodes anonymes et des expressions lambda. N'oubliez pas que la pratique est essentielle pour maîtriser les concepts de délégation. Essayez de créer vos propres exemples pour définir, attribuer et invoquer des délégués.

Vous pouvez explorer librement les capacités d'IronPDF grâce à sesversion d'essai gratuite. Si cela correspond aux besoins de votre projet, vous pouvez obtenir une licence à partir de $749.